diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000..5c98b42
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,2 @@
+# Default ignored files
+/workspace.xml
\ No newline at end of file
diff --git a/.idea/jsdom-with-fix.iml b/.idea/jsdom-with-fix.iml
new file mode 100644
index 0000000..c956989
--- /dev/null
+++ b/.idea/jsdom-with-fix.iml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..28a804d
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptSettings">
+    <option name="languageLevel" value="ES6" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..fe12e3a
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/jsdom-with-fix.iml" filepath="$PROJECT_DIR$/.idea/jsdom-with-fix.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/Changelog.md b/Changelog.md
new file mode 100644
index 0000000..fc4f479
--- /dev/null
+++ b/Changelog.md
@@ -0,0 +1,1782 @@
+<!-- Style guide:
+
+* Use past tense verbs to start the sentence, e.g. "Fixed", "Added", "Removed", ...
+* Each bullet point is a sentence (or more), and so ends with a period.
+* Package names are in `code`, sometimes [`linked`]().
+* Prefer referring to methods and properties via `someInstance.prop`, instead of `ClassName.prototype.prop`. (Never use `ClassName.prop` except for statics.)
+* Refer to attributes via `attr=""`.
+* Refer to elements via `<element>`.
+* Refer to events via `eventname`.
+* Refer to CSS properties via `'propname'`.
+* Never use the IDL terms "interface", "attribute", or "operation".
+* URL schemes are in `code`, e.g. `data:`.
+* Except in the headings, all version numbers get a "v" prefix, e.g. v12.2.0.
+* Follow the bullet point with parenthetical GitHub usernames when contributed by a non-core team member, e.g. "Fixed foo. (person)"
+
+Other guidelines:
+
+* Commit messages are primarily for jsdom developers. Changelog entries are primarily for users. Usually you cannot reuse the commit message.
+* Sometimes a single commit may expand to multiple changelog entries.
+* Do not include commits that have no user-facing impact, e.g. test rolls, refactorings, benchmark additions, etc.
+* For regression fixes, note the version in which something regressed.
+* Breaking changes get their own section.
+* Group in the order "Added", "Removed", "Changed", "Fixed".
+* Roughly order changes within those groupings by impact.
+-->
+
+## 16.2.0
+
+* Added support for custom elements! Congratulations and thanks to [@pmdartus](https://github.com/jsdom/jsdom/commits?author=pmdartus) for making this happen, after ten months of hard work and lots of effort poured into the complex architectural prerequisites in jsdom and supporting packages.
+* Fixed some issues when trying to use `Attr` as a `Node`, e.g. by checking its `baseURI` property or calling `attr.cloneNode()`.
+* Fixed a memory leak during parsing that was introduced in v14.0.0.
+* Fixed edge cases in number/string conversion used for certain element properties that reflected integer attributes.
+
+## 16.1.0
+
+* Added `console.timeLog()`.
+* Changed `Attr` to extend `Node`, to align with specifications. (ExE-Boss)
+* Changed `<noscript>` children to be parsed as nodes, instead of as text, when `runScripts` is left as the default of `undefined`. (ACHP)
+* Upgraded `cssstyle` to v2.1.0, which brings along fixes to handling of `rgba()` and `hsl()` colors. (kraynel)
+* Fixed some selection-related issues when manipulating the value of `<input>`s and `<textarea>`s. (Matthew-Goldberg)
+* Fixed various issues with `setTimeout()`, `setInterval()`, and `requestAnimationFrame()`, particularly around window closing and recursive calls.
+
+## 16.0.1
+
+* Fixed Node v10 and v11 support when `runScripts` was set.
+* Fixed the behavior when changing an `<input>`'s `type=""` attribute.
+* Fixed input validation behavior for `<input type="range">` when `max=""` is less than `min=""`.
+
+## 16.0.0
+
+For this release we'd like to welcome [@pmdartus](https://github.com/jsdom/jsdom/commits?author=pmdartus) to the core team. Among other work, he's driven the heroic effort of constructor prototype and reform in jsdom and its dependencies over the last few months, to allow us to move away from shared constructors and prototypes, and set the groundwork for custom elements support ([coming soon](https://github.com/jsdom/jsdom/pull/2548)!).
+
+Breaking changes:
+
+* Node v10 is now the minimum supported version.
+* The `dom.runVMScript()` API has been replaced with the more general `dom.getInternalVMContext()` API.
+* Each jsdom `Window` now creates new instances of all the web platform globals. That is, our old [shared constructor and prototypes](https://github.com/jsdom/jsdom/blob/35894a6703ed1f4de98942780bd99244ac27f600/README.md#shared-constructors-and-prototypes) caveat is no longer in play.
+* Each jsdom `Window` now exposes all JavaScript-spec-defined globals uniformly. When `runScripts` is disabled, it exposes them as aliases of the ones from the outer Node.js environment. Whereas when `runScripts` is enabled, it exposes fresh copies of each global from the new scripting environment. (Previously, a few typed array classes would always be aliased, and with `runScripts` disabled, the other classes would not be exposed at all.)
+
+Other changes:
+
+* Added the `AbstractRange`, `Range`, `StaticRange`, `Selection`, and `window.getSelection()` APIs.
+* Added working constructors for `Comment`, `Text`, and `DocumentFragment`.
+* Added `valueAsDate`, `valueAsNumber`, `stepUp()` and `stepDown()` to `<input>` elements. (kraynel)
+* Added `window.origin`.
+* Removed `document.origin`.
+* Fixed `<template>` to work correctly inside XML documents.
+* Fixed some bugs which would cause jsdom to choose the wrong character encoding because it was failing to detect `<meta charset>` or `<meta http-equiv="charset">` elements.
+* Fixed `input.type` to default to `"text"`. (connormeredith)
+* Fixed incorrect validation errors for `<input>` with fractional values for their `step=""` attribute. (kontomondo)
+* Fixed incorrect validation errors on readonly `<input>` elements.
+* Fixed `<input type="email" multiple pattern="...">` validation.
+* Fixed `fileReader.readAsDataURL()` to always base64-encode the result. (ytetsuro)
+* Fixed inserting `<img>` elements into documents without a browsing context to no longer crash when the `canvas` package is installed.
+* Fixed a memory leak when using `window.setTimeout()` or `window.setInterval()`.
+* Improved the performance of `getComputedStyle()`. (eps1lon)
+
+## 15.2.1
+
+* Fixed `JSDOM.fromURL()` handling of URLs with hashes in them, to no longer send the hash to the server and append an extra copy of it when constructing the `Document`. (rchl)
+* Fixed focusing an already-focused element to correctly do nothing, instead of firing additional `focus` events. (eps1lon)
+* Fixed typo in the not-implemented message for `mediaElement.addTextTrack()`. (mtsmfm)
+* Upgraded `nwsapi` minimum version to 2.2.0, which fixes issues with `::-webkit-` prefixed pseudo-elements and namespaced attribute selectors.
+
+## 15.2.0
+
+* Added basic style inheritance in `getComputedStyle()` for the `'visibility'` property. This sets the foundation for further work on inheritance, cascading, and specificity. (eps1lon)
+* Added `shadowRoot.activeElement`.
+* Added `readystatechange` events during document loading.
+* Added a stub for `form.requestSubmit()`, to match our existing stub for `form.submit()`.
+* Changed `el.tabIndex`'s default value, when no `tabindex=""` attribute was set, to reflect the updated specification.
+* Changed the exception thrown by `el.attachShadow()` on something that's already a shadow host, to reflect the updated specification.
+* Fixed the validation logic for `<input type="range">`.
+* Fixed `selectEl.value` when no `<option>` is selected to return the empty string, instead of the value of the first option. (tgohn)
+* Fixed various correctness issues with `new FormData(formElement)`. (brendo)
+* Fixed error messages when parsing XML to include the filename, instead of using `"undefined"`. (papandreou)
+* Fixed the logic for reflected properties to not be affected by overwriting of `el.getAttributeNS()` or `el.setAttributeNS()`.
+* Set `canvas` as an optional ``peerDependency`, which apparently helps with Yarn PnP support.
+
+## 15.1.1
+
+* Moved the `nonce` property from `HTMLScriptElement` and `HTMLStyleElement` to `HTMLElement`. Note that it is still just a simple reflection of the attribute, and has not been updated for the rest of the changes in [whatwg/html#2373](https://github.com/whatwg/html/pull/2373).
+* Fixed the `style` and `on<event>` properties to properly track their related attributes for SVG elements. (kbruneel)
+* Fixed `XMLHttpRequest` merging preflight and response headers. (thiagohirata)
+* Fixed `XMLHttpRequest` reserializing `content-type` request headers unnecessarily. See [whatwg/mimesniff#84](https://github.com/whatwg/mimesniff/issues/84) for more details. (thiagohirata)
+* Fixed `element.tagName` to be the ASCII uppercase of the element's qualified name, instead of the Unicode uppercase.
+
+## 15.1.0
+
+* Added the `Headers` class from the Fetch standard.
+* Added the `element.translate` getter and setter.
+* Fixed synchronous `XMLHttpRequest` on the newly-released Node.js v12.
+* Fixed `form.elements` to exclude `<input type="image">` elements.
+* Fixed event path iteration in shadow DOM cases, following spec fixes at [whatwg/dom#686](https://github.com/whatwg/dom/pull/686) and [whatwg/dom#750](https://github.com/whatwg/dom/pull/750).
+* Fixed `pattern=""` form control validation to apply the given regular expression to the whole string. (kontomondo)
+
+## 15.0.0
+
+Several potentially-breaking changes, each of them fairly unlikely to actually break anything:
+
+* `JSDOM.fromFile()` now treats `.xht` files as `application/xhtml+xml`, the same as it does for `.xhtml` and `.xml`. Previously, it would treat them as `text/html`.
+* If the `JSDOM` constructor's `contentType` option has a `charset` parameter, and the first argument to the constructor is a binary data type (e.g. `Buffer` or `ArrayBuffer`), then the `charset` will override any sniffed encoding in the same way as a `Content-Type` header would in browser scenarios. Previously, the `charset` parameter was ignored.
+* When using the `Blob` or `File` constructor with the `endings: "native"` option, jsdom will now convert line endings to `\n` on all operating systems, for consistency. Previously, on Windows, it would convert line endings to `\r\n`.
+
+## 14.1.0
+
+* Added activation behavior for `<a>` and `<area>` elements whose `href=""` points to a `javascript:` URL or fragment.
+* Added the `<datalist>` element's `options` property.
+* Added the `<input>` element's `list` property.
+* Added `PageTransitionEvent`, and the firing of `pageshow` events during loading.
+* Exposed the `External` class as a property of `window`.
+* Fixed HTML fragment parsing (via `innerHTML` and `outerHTML`) to be spec-compliant. (pmdartus)
+* Fixed HTML serialization (e.g. via `innerHTML`) breaking after setting certain properties to non-string values.
+* Fixed how disabling an element would cause its activation behavior to forever be null, even if it were re-enabled.
+* Fixed all access to attributes to ignore attributes with namespaces, per the spec.
+* Fixed `<style>`s to no longer apply to documents without a browsing context. This includes fixing a crash that would occur with such styles if they had an `@import` rule.
+* Fixed `<option>`'s `label` and `value` properties to return correct values in various edge cases.
+* Fixed the `load` event during document loading to target the `Document`, not the `Window`.
+* Fixed the `pretendToBeVisual` option to propagate to child subframes, as well as the main `Window`. (pyrho)
+* Updated the minimum [`nwsapi`](https://www.npmjs.com/package/nwsapi) version from v2.1.1 to v2.1.3, bringing along a few fixes in our selector engine.
+
+## 14.0.0
+
+Breaking changes:
+
+* `JSDOM.fragment()` now creates fragments whose document has no [browsing context](https://html.spec.whatwg.org/multipage/#concept-document-bc), i.e. no associated `Window`. This means the `defaultView` property will be null, resources will not load, etc.
+* `JSDOM.fragment()`, called with no arguments, now creates a `DocumentFragment` with no children, instead of with a single child text node whose data was `"undefined"`.
+
+Other changes:
+
+* Fixed a regression in v13.2.0 when calling `element.blur()` on a focused element.
+* Fixed inserting `<link>` elements into documents with no browsing context to no longer crash if the originating `JSDOM` was configured to fetch the resource. Now, per spec, `<link>` elements only attempt to fetch if they are browsing-context connected.
+* Fixed `<template>` elements to have the correct semantics, of using a separate browsing-context-less document to store its contents. In particular this means resources will not be fetched for elements inside the `<template>`, as per spec.
+
+## 13.2.0
+
+* Added support for `MutationObserver`s! (pmdartus)
+* Added support for XML documents loaded in frames and iframes; previously this would error.
+* Added the `<progress>` element's `value`, `max`, and `position` properties.
+* Added `navigator.plugins` and `navigator.mimeTypes`. (But, they are always empty.)
+* Fixed `<summary>` elements respond to `click` events by toggling their parent `<details>`.
+* Fixed `<summary>` elements to be focusable.
+* Fixed XML document DOCTYPE parsing to preserve any custom name values.
+* Fixed XML documents to default to UTF-8, not windows-1252 like HTML documents do.
+* Fixed all events fired by jsdom to have `isTrusted` set to `true`.
+* Fixed `DOMParser`-created documents to have their `readyState` set to `"complete"`.
+* Fixed how nested `<fieldset>`s get disabled.
+* Fixed `getComputedStyle()` to throw a sensible exception when passed the wrong argument, instead of one that exposes jsdom internals.
+* Upgraded our [`saxes`](https://github.com/lddubeau/saxes) dependency, so that it now correctly errors on XML fragments like `<foo bar:="1"/>`.
+
+## 13.1.0
+
+* Added `el.insertAdjacentElement()` and `el.insertAdjacentText()`.
+* Added the firing of a cancelable `reset` event to `form.reset()`. (epfremmer)
+* Added the `type`, `value`, and `defaultValue` properties to `<output>` elements, including their form reset behavior. (epfremmer)
+* Added the `outputEl.htmlFor` property.
+* Fixed the performance of parsing large text nodes, particularly noticeable for large inline `<style>` or `<script>` elements. This regressed in v11.6.0. To learn more, see [V8 issue #6730](https://bugs.chromium.org/p/v8/issues/detail?id=6730#c4).
+* Fixed the `style` property on `<a>` and `<area>` elements. This regressed in v13.0.0.
+* Fixed `node.isConnected` to not always return false for nodes inside a shadow tree. (pmdartus)
+* Fixed `<button type="reset">` and `<input type="reset">` elements to actually perform a form reset when clicked, instead of doing nothing. (epfremmer)
+* Fixed `el.setCustomValidity()` for `<output>` and `<fieldset>`.
+* Fixed activation behavior when dispatching bubbling `click` events, so that for example calling `el.click()` on the child of a submit button element will submit the form.
+* Fixed our XML parsing code to ignore text outside the root element, instead of treating it as an error. (lddubeau)
+* Fixed XML serialization when elements had an unknown prefix.
+* Fixed radio button group name matching to be case-sensitive, per [a spec update](https://github.com/whatwg/html/commit/6acdb2122298d2bb7bb839c0a61b4e1f9b0f9bc9).
+* Fixed `focus`/`blur` events to be composed.
+* Fixed `mediaElement.duration` to default to `NaN`.
+* Fixed `olEl.start` to default to `1`.
+* Fixed using `XMLHttpRequest` against non-existant `file:` URLs to treat that as a network error, instead of crashing. (pascalbayer) Note that in the future we may completely disable `XMLHttpRequest` usage against `file:` URLs to follow the browser security model.
+* Fixed `document.title` in SVG documents.
+* Fixed `titleElement.text` to return the child text content, instead of being the same as `titleElement.innerHTML`.
+* Fixed `<textarea>`s to properly account for child CDATA section nodes changing.
+* Fixed the value of `Element.prototype[Symbol.unscopables]`.
+
+## 13.0.0
+
+Breaking change:
+
+* Removed support for v1.x of the [`canvas`](https://github.com/Automattic/node-canvas) package, in favor of v2.x. This also removes support for `canvas-prebuilt`, since `canvas` v2.x has a built-in prebuilt version.
+
+Other changes:
+
+* Added proper XML serialization, based on the [`w3c-xmlserializer`](https://github.com/jsdom/w3c-xmlserializer) package. Previously we were just using the HTML serialization, even in XML documents.
+* Added the `storageEvent.initStorageEvent()` method.
+* Added support for the `passive` option to `addEventListener()`.
+* Added the `relList` property to `<a>`, `<area>`, and `<link>` elements.
+* Fixed our implementation of the node tree modification constraints (for example the [ensure pre-insertion validity](https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity) algorithm). It is no longer possible to add, remove, or move nodes to create impossible DOM trees. (pmdartus)
+
+## 12.2.0
+
+* Added support for shadow DOM! This includes shadow roots, slots, composed events, and more. (pmdartus)
+* Added the `element.toggleAttribute()` method.
+* Fixed `XMLHttpRequest` sometimes sending an empty request body after a preflight request. (andreasf)
+* Fixed the `formElement.form` property to use an algorithm that also checks the `form=""` attribute, instead of always looking for the closest ancestor `<form>` element. (jamietre)
+* Stopped swallowing errors when the `canvas` or `canvas-prebuilt` packages were installed, but failed to load. (joscha)
+
+## 12.1.0
+
+* Dramatically upgraded our XML parser, from the unmaintained [`sax`](https://github.com/isaacs/sax-js) package to the well-maintained [`saxes`](https://github.com/lddubeau/saxes) replacement. This increases our specification conformance, including rejecting certain ill-formed XML documents that were previously accepted, and properly handling other constructs like empty comments, CDATA sections, and `<script>` elements. (lddubeau)
+* Added `fieldsetEl.elements` and `fieldsetEl.type` properties.
+* Added the `options` parameter to `dom.runVMScript()`. (SimenB)
+* Added the ability for custom resource loader `fetch()` implementations to see what element initiated the fetch. (sarvaje)
+* Fixed `input` and `change` events for `<input>` elements to be trusted and uncancelable.
+* "Fixed" `<script>`s with the `async` attribute to not execute before sync `<script>`s that precede them. We still do not, in general, have proper execution of scripts during the initial parsing of a document, so this fix is more of a reduction of badness than an alignment with the specification. This behavior regressed in v12.0.0. (sarvaje)
+
+## 12.0.0
+
+This major release brings along our [new resource loader API](https://github.com/jsdom/jsdom#loading-subresources), finally bringing all the capabilities from jsdom v9 to the new (jsdom v10+) API. Thanks very much to [@sarvaje](https://github.com/sarvaje) for his work to make this possible!
+
+Breaking changes:
+
+* jsdom now requires Node.js v8.
+* Removed the old jsdom API, as the new API now has all the capabilities you need.
+* Updated our [`parse5`](https://github.com/inikulin/parse5/) dependency to v5, which changes the format of the node locations returned by `dom.nodeLocation()`.
+* Updated our [`whatwg-url`](https://github.com/jsdom/whatwg-url) dependency to v7, which changes the origin of `file:` URLs to be an opaque origin (and thus `file:` URLs are no longer same origin to each other).
+
+Other changes:
+
+* Added `countReset()`, `dir()` and `dirxml()` methods to `console`.
+* Added the `InputEvent` class.
+* Added `window.status`.
+* Added `htmlElement.draggable`.
+* Fixed `window.frameElement` to correctly return an actual `HTMLElement` instance, instead of a jsdom internal class.
+* Fixed cloning of `textarea` elements to preserve their values.
+* Fixed `select.selectedOptions` sometimes returning outdated results.
+* Fixed CSS selection APIs sometimes returning outdated results, especially for state pseudo-class selectors like `:checked`.
+* Fixed CSS selection APIs to throw an error for invalid selectors even when used on empty nodes.
+* Fixed `window.name` to default to the empty string, per spec, instead of `"nodejs"`.
+* Fixed the default User-Agent to say "unknown OS" instead of "undefined" when jsdom is used in web browsers.
+
+## 11.12.0
+
+* Added `window.localStorage`, `window.sessionStorage`, and `StorageEvent` support. These are currently only stored in-memory; file an issue if you need persistent (on-disk) storage capability so we can discuss adding that. This feature includes the new `storageQuota` option for controlling how much can be stored.
+* Added `element.closest()`. (caub)
+* Changed `hashchange` and `popstate` events to no longer bubble, per a specification update.
+* Fixed the old API in Node.js v10 to not throw, when given input that is not a valid file path (such as a typical HTML string).
+* Upgraded `cssstyle` to v1.0.0, bringing along various fixes to our CSS parser and object model. (eddies)
+* Upgraded `nwsapi` to v2.0.7, bringing along various fixes to our selector engine.
+
+## 11.11.0
+
+* Added `node.getRootNode()`. (FrecksterGIT)
+* Added `label.control`. (FrecksterGIT)
+* Added `el.labels` for form control elements. (FrecksterGIT)
+* Fixed the `contentType` of `Document`s created through `<iframe>`s.
+* Fixed the `contentType` and `origin` of `Document`s created through `document.implementation.createDocument()`.
+* Fixed `sourceEl.srcset` to return the value of the `srcset=""` attribute, instead of the `cite=""` attribute.
+* Fixed `node.normalize()` to not modify non-`Text` nodes. (lddubeau)
+* Upgraded `cssstyle` to v0.3.1, bringing along various fixes to our CSS parser and object model. (jsakas)
+* Upgraded `whatwg-url` to v6.4.1, fixing the interaction of `URL`'s `href` and `searchParams` properties.
+* Upgraded our selector matching engine from `nwsmatcher` to `nwsapi`, bringing along extensive fixes, performance improvements, and additional selector support.
+
+## 11.10.0
+
+* Added `event.srcElement` and `event.returnValue`.
+* Fixed `XMLHttpRequest` to correctly set the User-Agent header, and set it on CORS preflight requests. (BehindTheMath)
+
+## 11.9.0
+
+* Added `node.lookupPrefix()`, `node.lookupNamespaceURI()` and `node.isDefaultNamespace()`.
+* Fixed the cloning of `Document`s; previously it would not clone all of the appropriate state, and would sometimes add an extra document type node.
+* Fixed various edge cases in the `textContent` and `nodeValue` properties.
+* Fixed `canvas.toBlob()` to properly pass through the JPEG quality argument, instead of always passing zero to `node-canvas`. (challakoushik)
+
+## 11.8.0
+
+* Added the full constraint validation API, i.e. `willValidate`, `validity`, `validationMessage`, `checkValidity()`, `reportValidity()`, and `setCustomValidity()`, on `HTMLButtonElement`, `HTMLFieldSetElement`, `HTMLFormElement`, `HTMLInputElement`, `HTMLObjectElement`, `HTMLOutputElement`, `HTMLSelectElement`, and `HTMLTextAreaElement`. (kontomondo)
+* Added `getElementById()` to `DocumentFragment`.
+
+## 11.7.0
+
+* Added the boolean return value to `DOMTokenList`'s `replace()` method, per the recent spec addition.
+* Added `FileReader`'s `readAsBinaryString()` method, as it has been added back to the specification.
+* Fixed event handlers to be own properties of each `Window`, instead of on `Window.prototype`. (Fetz)
+* Fixed an exception that would sometimes get raised when removing an `<img>` element's `src=""` attribute. (atsikov)
+* Fixed `abort` events on `AbortSignal`s to have their `isTrusted` set to true.
+* Fixed some argument conversions in `XMLHttpRequest`'s `open()` method.
+* Improved MIME type and `data:` URL parsing throughout jsdom, by using the new [`whatwg-mimetype`](https://www.npmjs.com/package/whatwg-mimetype) and [`data-urls`](https://www.npmjs.com/package/data-urls) packages.
+* Removed some unnecessary `.webidl` files that were included in the npm package.
+
+## 11.6.2
+
+* Fixed another regression (since v11.6.0) in `<style>` elements, where they would omit a series of parsing `jsdomError` events for any style sheet text containing spaces.
+* Generally improved the spec-conformance of when `<style>` and `<script>` elements are evaluated; for example, `<script>` elements inserted by `innerHTML` are no longer evaluated.
+
+## 11.6.1
+
+* Fixed one regression (since v11.6.0) in `<style>` elements, where their `sheet` property would sometimes be `null` when it should not be.
+* Fixed a case where a `<style>` element's `sheet` property would be left as a `CSSStyleSheet` despite it not being in the document.
+
+Another regression remains where we are emitting spurious CSS-parsing `jsdomError` events; see [#2123](https://github.com/jsdom/jsdom/issues/2123). We also discovered a large amount of preexisting brokenness around `<style>`, `<link>`, and `@import`; see [#2124](https://github.com/jsdom/jsdom/issues/2124) for more details.
+
+We'll try to fix these soon, especially the regression.
+
+## 11.6.0
+
+* Added a fully-functioning `WebSocket` implementation!
+* Added a `window.performance` implementation, including the basics of the [High Resolution Time](https://w3c.github.io/hr-time/) specification: `performance.now()`, `performance.timeOrigin`, and `performance.toJSON()`.
+* Added support for all of the public API of `HTMLMeterElement`, except for `meterEl.labels`.
+* Added the `locationbar`, `menubar`, `personalbar`, `scrollbars`, `statusbar`, and `toolbar` properties to `Window`.
+* Added more properties to `window.screen`: `availWidth`, `availHeight`, `colorDepth`, and `pixelDepth`. All of its properties are now getters as well.
+* Added `window.devicePixelRatio`.
+* Added `getModifierState()` to `MouseEvent` and `KeyboardEvent`.
+* Added a setter for `HTMLInputElement`'s `files` property.
+* Added support for the `endings` option to the `Blob` constructor.
+* Fixed firing various event firings to have the correct default values, e.g. the properties of `MouseEvent` when using `element.click()`.
+* Fixed the firing of `popstate` and `hashchange` events during fragment navigation to make them trusted events.
+* Fixed `data:` URL parsing to not include the fragment portions.
+* Fixed all URL-accepting properties to properly perform [scalar value string conversion](https://infra.spec.whatwg.org/#javascript-string-convert) and URL resolution.
+* Fixed many other small edge-case conformance issues in the API surface of various web APIs; see [#2053](https://github.com/jsdom/jsdom/pull/2053) and [#2081](https://github.com/jsdom/jsdom/pull/2081) for more information.
+* Fixed various APIs to use ASCII lowercasing, instead of Unicode lowercasing, for element and attribute names.
+* Fixed the encoding of a document created via `new Document()` to be UTF-8.
+* Fixed event handler properties behavior when given non-callable objects.
+* Increased the performance of parsing HTML documents with large numbers of sibling elements.
+* Removed `probablySupportsContext()` and `setContext()` from `HTMLCanvasElement`, per spec updates.
+* Removed the nonstandard `window.scrollLeft` and `window.scrollTop` properties, and the `window.createPopup()` method.
+
+## 11.5.1
+
+(This should have been a minor release; oops.)
+
+* Added `AbortSignal` and `AbortController`.
+* Fixed validation for file `<input>`s and implemented validation for more input types.
+
+## 11.4.0
+
+For this release we'd like to welcome [@Zirro](https://github.com/jsdom/jsdom/commits?author=Zirro) to the core team; his contributions over the course of this year have enhanced jsdom immensely.
+
+* Added a rudimentary set of SVG element classes, namely `SVGElement`, `SVGGraphicsElement`, `SVGSVGElement`, `SVGTests`, `SVGAnimatedString`, `SVGNumber`, and `SVGStringList`. The main impact here is that SVG elements are now instances of `SVGElement`, instead of being simply `Element` (as they were in v11.3.0) or `HTMLUnknownElement` (as they were in v11.2.0 and previously). The only concrete subclass that is implemented is `SVGSVGElement`, for `<svg>` itself; other tags will not map to their correct classes, because those classes are not yet implemented.
+* Added the new `pretendToBeVisual` option, which controls the presence of the new `requestAnimationFrame()` and `cancelAnimationFrame()` methods, and the new values of `document.hidden`/`document.visibilityState`. [See the README](https://github.com/jsdom/jsdom#pretending-to-be-a-visual-browser) for more information. (SimenB)
+* Added the `append()` and `prepend()` methods to `Document`, `DocumentFragment`, and `Element`. (caub)
+* Added the `before()`, `after()`, and `replaceWith()` methods to `DocumentType`, `Element`, and `CharacterData`. (caub)
+* Added `node.isConnected`.
+* Added `node.isSameNode()`.
+* Added support for parsing CDATA sections in XML documents, including in `domParser.parseFromString()`. (myabc)
+* Added appropriate `input.value` getter/setter logic for `<input type="file">`.
+* Significantly improved the spec-compliance of `NamedNodeMap`, i.e. of `element.attributes`, such that retrieving named or indexed properties will now always work properly.
+* Fixed `domParser.parseFromString()` to not parse HTML character entities in XML documents. (myabc)
+* Fixed `xhr.abort()` to clear any set headers.
+* Fixed `XMLHttpRequest` to always decoded responses as UTF-8 when `responseType` is set to `"json"`.
+* Fixed `XMLHttpRequest` CORS header handling, especially with regard to preflights and Access-Control-Allow-Headers. (ScottAlbertine)
+* Fixed the behavior of `radioButton.click()` to fire appropriate `input` and `change` events. (liqwid)
+* Fixed `querySelector()`/`querySelectorAll()` behavior for SVG elements inside `<template>` contents `DocumentFragment`s, including those created by `JSDOM.fragment()`. (caub)
+* Fixed the line number reporting in exception stack traces when using `<script>` elements, when `includeNodeLocations` is set.
+* Removed the `<applet>` element, [following the spec](https://github.com/whatwg/html/pull/1399).
+
+## 11.3.0
+
+For this release we'd like to formally welcome [@TimothyGu](https://github.com/jsdom/jsdom/commits?author=TimothyGu) to the core team, as a prolific contributor. He will join the illustrious ranks of those who do so much work on jsdom that we no longer note their names in the changelog.
+
+* Added `table.tHead`, `table.tFoot`, and `table.caption` setters, and the `table.createTBody()` method.
+* Added `CompositionEvent` and `WheelEvent` classes.
+* Added a `<details>` element implementation. (Zirro)
+* Added stub `<marquee>` and `<picture>` element implementations. (Zirro)
+* Updated `uiEvent.initUIEvent()`, `keyboardEvent.initKeyboardEvent()`, and `mouseEvent.initiMouseEvent()` to match the latest specifications.
+* Converted `DOMTokenList` (used by, e.g., `element.classList`) to use proxies for improved specification compliance and "liveness".
+* Fixed the `DOMException` class to be spec-compliant, including its constructor signature.
+* Fixed some subtle interactions between inline event handlers and other event listeners.
+* Fixed the element interface used when creating many of the more obscure elements.
+* Fixed the behavior of the `table.rows` getter, and the `table.createCaption()` and `table.deleteRow()` methods.
+* Fixed incorrect sharing of methods between interfaces that used mixins (e.g. previously `document.querySelector === documentFragment.querySelector`, incorrectly).
+* Fixed `FocusEvent` creation, which regressed in v11.2.0.
+* Fixed `UIEvent` to only allow initializing with `Window` objects for its `view` property.
+* Fixed the behavior of `tr.rowIndex` and `tr.deleteCall()`.
+* Fixed the element interface for `<td>` and `<th>` to be simply `HTMLTableCellElement`, and improved that class's spec compliance.
+* Fixed calling `label.click()` to not trigger the labeled control's activation behavior when the control is disabled. (schreifels)
+* Fixed `document.getElementsByName()` to return a `NodeList` instead of a `HTMLCollection`. (Zirro)
+* Significantly sped up synchronous `XMLHttpRequest`. (Zirro)
+
+## 11.2.0
+
+This release brings with it a much-awaited infrastructure change, as part of [webidl2js v7.3.0](https://github.com/jsdom/webidl2js/releases/tag/v7.3.0) by the ever-amazing TimothyGu: jsdom can now generate spec-compliant versions of classes that have "`Proxy`-like" behavior, i.e. allow getting or setting keys in unusual ways. This enables a number of improvements, also by TimothyGu:
+
+* Significantly improved the spec-compliance and "liveness" of both `NodeList` and `HTMLCollection`, such that retrieving properties via indices or (in `HTMLCollection`'s case) `id`/`name` values will always work correctly.
+* Added `element.dataset` support.
+* Added indexed and named access to `<select>` elements, as well as the corresponding `item()` and `namedItem()` methods.
+* Added suport for `FileList` indexed properties, i.e. `fileList[i]`.
+* Made `select.options` an instance of the newly-implemented `HTMLOptionsCollection`, instead of just a `HTMLCollection`.
+
+This infrastructure will allow us to improve and implement many other similar behaviors; that work is being tracked in [#1129](https://github.com/jsdom/jsdom/issues/1129).
+
+In addition to these improvements to the object model, we have more work to share:
+
+* Added no-op APIs `document.clear()`, `document.captureEvents()`, `document.releaseEvents()`, `window.external.AddSearchProvider()`, and `window.external.IsSearchProviderInstalled()`. (Zirro)
+* Added active checks to prevent reentrancy in `TreeWalker` and `NodeIterator`.
+* Updated the interaction between a `<textarea>`'s `value`, `defaultValue`, and `textContent` per [a recent spec change](https://github.com/whatwg/html/commit/5afbba1cf62ee01bc6af3fd220d01f3f7591a0fc)
+* Fixed elements with `id="undefined"` shadowing the `undefined` property of the global object. (TimothyGu)
+* Fixed matching in `getElementsByClassName()` to be ASCII case-insensitive, instead of using JavaScript's `toLowerCase()`.
+* Improved some behaviors around navigating to fragments. (ForbesLindesay)
+* Improved `XMLHttpRequest` and `FileReader` behavior, mainly around event handlers, `abort()`, and network errors.
+* Improved edge-case spec compliance of `NodeIterator`.
+
+## 11.1.0
+
+* Added `javascript:` URL "navigation" via `window.location`, at least by evaluating the side effects. It still doesn't actually navigate anywhere. (ForbesLindesay)
+* Updated `whatwg-url` to v6.1.0, bringing along origin serialization changes and `URLSearchParams` among various other fixes. (ForbesLindesay)
+* Fixed `javascript:` URL loading for iframes to do proper percent-decoding and error reporting.
+* Fixed corrupted `XMLHttpRequest` responses when they were over 1 MiB.
+* Fixed timers to not start after a window is `close()`d, which could cause strange errors since most objects are unusable at that point. (Enverbalalic)
+
+## 11.0.0
+
+Breaking changes:
+
+* Custom parsers, via the `parser` option to the old API, can no longer be specified. They were never tested, often broken, and a maintenance burden. The defaults, of [parse5](https://www.npmjs.com/package/parse5) for HTML and [sax](https://www.npmjs.com/package/sax) for XML, now always apply.
+* Due to a parse5 upgrade, the location info objects returned by `dom.nodeLocation()` or the old API's `jsdom.nodeLocation()` now have a different structure.
+* Fixed how `runScripts` applies to event handler attributes; now they will no longer be converted into event handler functions unless `runScripts: "dangerously"` is set. However, event handler _properties_ will now work with any `runScripts` option value, instead of being blocked.
+
+Other changes:
+
+* Overhauled how event handler properties and attributes work to follow the spec. In particular, this adds various `oneventname` properties to various prototypes, ensures the correct order when interleaving event handlers and other event listeners, and ensures that event handlers are evaluated with the correct values in scope.
+* Upgraded parse5 from v1 to v3, bringing along several correctness improvements to HTML parsing. (Zirro)
+* Updated `Location` properties to be on the instance, instead of the prototype, and to be non-configurable.
+* Significantly improved the performance of `HTMLCollection`, and thus of parsing large documents. (Zirro)
+* Significantly improved the performance of `getComputedStyle()` by removing unsupported selectors from the default style sheet. (flaviut)
+* Fixed all web platform methods that accepted web platform objects to perform proper type checks on them, throwing a `TypeError` when given invalid values. (TimothyGu)
+* Fixed the `Symbol.toStringTag` properties to be non-writable and non-enumerable. (TimothyGu)
+* Fixed `tokenList.remove()` when the `DOMTokenList` corresponded to a non-existant attribute. (Zirro)
+* Fixed `fileReader.abort()` to terminate ongoing reads properly.
+* Fixed `xhr.send()` to support array buffer views, not just `ArrayBuffer`s. (ondras)
+* Fixed non-`GET` requests to `data:` URLs using `XMLHttpRequest`. (Zirro)
+* Fixed form submission to no longer happen for disconnected forms.
+* Fixed body event handler attributes to be treated like all others in terms of how they interact with `runScripts`.
+* Many updates per recent spec changes: (Zirro)
+  * Updated `tokenList.replace()` edge-case behavior.
+  * Invalid qualified names now throw `"InvalidCharacterError"` `DOMException`s, instead of `"NamespaceError"` `DOMException`s.
+  * Changed `input.select()` to no longer throw on types where selection does not apply.
+  * Updated `event.initEvent()` and various related methods to have additional defaults.
+  * Stopped lowercasing headers in `XMLHttpRequest` responses.
+  * Started lowercasing headers in `xhr.getAllResponseHeaders()`, and separating the header values with a comma-space (not just a comma).
+  * Allow a redirect after a CORS preflight when using `XMLHttpRequest`.
+  * Tweaked username/password CORS treatment when using `XMLHttpRequest`.
+  * Changed `xhr.overrideMimeType()` to no longer throw for invalid input.
+  * Removed `blob.close()` and `blob.isClosed()`.
+* Removed some remaining not-per-spec `toString()` methods on various prototypes, which were made redundant in v10.1.0 but we forgot to remove.
+
+## 10.1.0
+
+* Added the value sanitization algorithm for password, search, tel, text, color, email, and url input types. (Zirro)
+* Added `Symbol.toStringTag` to all web platform classes, so that now `Object.prototype.toString.call()` works as expected on jsdom objects.
+* Added the `select.selectedOptions` property.
+* Removed the `toString()` methods on various prototypes that returned `"[object ClassName]"` in an attempt to fake the `Symbol.toStringTag` behavior.
+* Changed `XMLHttpRequest` to pre-allocate a 1 MiB buffer, which it grows exponentially as needed, in order to avoid frequent buffer allocation and concatenation. (skygon)
+* Fixed a variety of properties that were meant to always return the same object, to actually do so. (Zirro)
+* Fixed inheritance of the `runScripts` and `resources` options into iframes.
+* Fixed an uncaught exception that occurred if you called `xhr.abort()` during a `readystatechange` event.
+
+## 10.0.0
+
+This release includes a complete overhaul of jsdom's API for creating and manipulating jsdoms. The new API is meant to be much more intuitive and have better defaults, with complete documentation in the newly-overhauled README. We hope you like it!
+
+As discussed in the new README, the old API is still available and supported via `require("jsdom/lib/old-api.js")`, at least until we have ported all of its features over to the new API. It will, however, not be gaining any new features, and we suggest you try the new API unless you really need the customizable resource loading the old API provides.
+
+Apart from the new API, the following changes were made, with breaking changes bolded:
+
+* **Removed support for Node.js v4 and v5**, as we have started using new JavaScript features only supported in Node.js v6 onwards.
+* **Changed the `omitJsdomErrors` option to `omitJSDOMErrors`**, for consistency [with web platform APIs](https://w3ctag.github.io/design-principles/#casing-rules).
+* Added `document.dir`. (Zirro)
+* Updated the `<a>` and `<area>` APIs to the latest specification, and fixed a few bugs with them. (makana)
+* Fixed `<img>` elements to no longer fire `load` events unless their image data is actually loaded (which generally only occurs when the `canvas` package is installed).
+* Fixed `XMLHttpRequest` preflights to forward approved preflight headers to the actual request. (mbroadst)
+* Fixed `htmlElement.dir` to properly restrict its values to `"ltr"`, `"rtl"`, or `"auto"`. (Zirro)
+* Fixed setting `innerHTML` to the empty string to no longer be a no-op. (Zirro)
+* Fixed the origin-checking logic in `window.postMessage()`, so that now you don't always have to pass an origin of `"*"`. (jmlopez-rod)
+* Improved the `xhr.open()` error message when there are not enough arguments. (lencioni)
+
+## 9.12.0
+
+* Added the `Option` named constructor. (NAlexPear)
+* Added support for the `canvas-prebuilt` npm package as an alternative to `canvas`. (asturur)
+* Fixed `setTimeout()` and `setInterval()` to always return a positive integer, instead of returning `0` the first time were called. (yefremov)
+* Fixed `jsdom.env()` to preserve URL fragments across redirects. (josephfrazier)
+* Fixed `optionEl.text` and `optionEl.value` to be more spec-compliant.
+* Fixed `event.stopImmediatePropagation()` to actually stop immediate propagation, not just propagation.
+* Fixed `clearTimeout()` and `clearInterval()` to work correctly when using jsdom browserified.
+
+## 9.11.0
+
+* Added dummy properties `offsetTop`, `offsetLeft`, `offsetWidth`, and `offsetHeight` that always return `0`, and `offsetParent` which always returns `null`, for all HTML elements. (yefremov)
+* Fixed various edge cases in our type conversions applied to method arguments and setters throughout the web platform APIs implemented by jsdom.
+
+## 9.10.0
+
+* Added `forEach`, `keys`, `values`, and `entries` methods to `NodeList`.
+* Added `event.cancelBubble`.
+* Added dummy properties `scrollWidth`, `scrollHeight`, `clientTop`, `clientLeft`, `clientWidth`, and `clientHeight` that always return `0` to all elements. (alistairjcbrown)
+* Updated many aspects of `Blob`, `File`, and `FileReader` to better match the File API specification. (TimothyGu)
+* Fixed the progress and readystatechange events fired by `XMLHttpRequest` to match recent specification changes and test updates.
+* Fixed `element.getClientRects()` to return an empty array, instead of an array containing a dummy bounding box. (alistairjcbrown)
+* Changed `navigator.vendor` to return `"Apple Computer, Inc."` instead of `"Google Inc."`, since we have chosen the WebKit [navigator compatibility mode](https://html.spec.whatwg.org/multipage/webappapis.html#concept-navigator-compatibility-mode).
+
+## 9.9.1
+
+* Removed the use of `array.includes` to fix a compatibility issue with Node.js v4.
+
+## 9.9.0
+
+* Added `CDATASection` nodes, including `document.createCDATASection`. (snuggs)
+* Added `node.wholeText`. (jdanyow)
+* Added a setter for `document.body`.
+* Added `document.embeds`, `document.plugsin`, and `document.scripts`. These were supposed to be added in 9.5.0 but were mistakenly omitted.
+* Fixed `element.insertAdjacentHTML` to work when the element has null or the document as its parent node, as long as the insertion position is `"afterbegin"` or `"beforeend"`.
+* Fixed form submission to only hit the "not implemented" virtual console message when form submission is _not_ canceled, instead of when it is.
+* Fixed an issue where the event listener was not being correctly removed when using the `{ once: true }` option to `addEventListener`. (i8-pi)
+* Fixed an error that was thrown when using `XHTMLHttpRequest` and POSTing JSON contents to an endpoint that requires CORS while using an `Authorization` header. (dunnock)
+* Fixed `document.body` and `document.title` to act more correctly in various edge cases.
+* Fixed `HTMLCollection` named access to return the first element encountered, not the last.
+
+## 9.8.3
+
+* Fixed syntax errors in Node.js v4.
+
+## 9.8.2
+
+* Fixed `DOMTokenList` and `getElementsByClassName` to only split on ASCII whitespace, not all Unicode whitespace.
+
+## 9.8.1
+
+* Fixed an error that occurred when passing no class names to `getElementsByClassName`, e.g. `getElementsByClassName("")` or `getElementsByClassName(" ")`.
+
+## 9.8.0
+
+* Added the `blob.isClosed` property. (TimothyGu)
+* Fixed the `file.lastModified` property to be on `File` instead of on `Blob`. (TimothyGu)
+* Fixed the `file.lastModified` property to default to the time of the `File` object's creation, not the time that the property is accessed. (TimothyGu)
+* Fixed a minor edge-case regression where non-HTML elements with the name `"iframe"` became focusable in v9.7.0.
+
+## 9.7.1
+
+* Fixed a performance regression introduced in 9.5.0 for modifying the DOM. It was particularly noticable during initial parsing of a document with many elements; for example, one test showed parsing ten thousand elements taking 36.4 seconds, whereas after this fix it is back to a more reasonable 0.4 seconds.
+
+## 9.7.0
+
+* Added `EventListenerOptions` support to `addEventListener` and `removeEventListener`, including both the `once` and `capture` options. (GianlucaGuarini)
+* Added `document.hasFocus()` (acusti)
+* Fixed the focus management to ensure that focusing something inside an `iframe` will also focus the `iframe` itself. (acusti)
+
+## 9.6.0
+
+* Added `HTMLCollection.prototype[Symbol.iterator]`, so you can use `for`-`of` loops over `HTMLCollection`s now. (i8-pi)
+* Fixed `file.lastModified` to return the current time as the default, instead of `0`.
+* Fixed cloning of `Attr`s to properly clone the namespace prefix.
+* Tweaked `XMLHttpRequest` progress event ordering slightly to better match the spec and browsers.
+* Tweaked the behavior of calling `event.stopPropagation` and `event.stopImmediatePropagation` on already-dispatched events, per [the latest changes to the DOM Standard](https://github.com/whatwg/dom/commit/806d4aab584f6fc38c21f8e088b51b8ba3e27e20).
+
+## 9.5.0
+
+* Added `document.scripts`, `document.embeds`, and `document.plugins`.
+* Fixed `document.getElementsByTagName` and `document.getElementsByTagNameNS` to return `HTMLCollection`s instead of `NodeList`s, and to follow the spec algorithms more exactly.
+* Fixed various `HTMLCollection`-returning getters such as `document.applets` or `table.cells` to be more spec-compliant.
+* Fixed the resource loader to respect the `agent` and `agentClass` options, not just the `agentOptions` one.
+* Fixed `console.groupCollapse` to be `console.groupCollapsed` (and changed the virtual console accordingly).
+
+## 9.4.5
+
+* Fixed `error` events from failed resource loads going missing since v9.4.3. I really should have tested that release better.
+
+## 9.4.4
+
+* Fixed a leftover `console.log` introduced in the error handling path in v9.4.3.
+
+## 9.4.3
+
+* Fixed spurious `"jsdomError"`s occuring when closing a window, due to aborted resource loads.
+
+## 9.4.2
+
+* Fixed what would happen when inline event handlers (such as `element.onclick`) would return non-boolean values (such as `undefined`); it would previously erroneously cancel the event, in many cases. (dmethvin)
+* Upgraded the minimum tough-cookie version to ensure all installations are protected against [a security advisory](https://nodesecurity.io/advisories/130).
+
+## 9.4.1
+
+* Implemented the cloning steps for `<input>` elements, so that cloned inputs properly copy over their value, checkedness, dirty value flag, and dirty checkedness flag. (matthewp)
+
+## 9.4.0
+
+* Added the `DOMParser` API. It is spec-compliant, including producing `<parsererror>` elements, except that the produced documents do not have the same URL as the creating document (they instead always have `"about:blank"`).
+* Added strict XML parsing when using `parsingMode: "xml"`. Creating documents will now fail, just like in a browser, when ill-formed XHTML markup is used.
+* Added some rudimentary application of XML `<!ENTITY` declarations.
+* Added `window.frameElement`, although without appropriate cross-origin security checks.
+* Added the `jsdom.evalVMScript` public API.
+* Added more custom request agent support: you can now pass `agent` and `agentClass` in addition to `agentOptions`. (frarees)
+* Updated our elements-being-disabled semantics to more closely match the spec, in particular with regard to being descendants of `<fieldset disabled>`.
+* Updated `FormData` for [recent spec fixes](https://github.com/whatwg/xhr/commit/1a75845e67792418a7721d516266ad01a90f2062): blobs, files, and filenames should now all work like you'd expect.
+* Updated the `FormData` constructor to use the proper, rather-complex, [constructing the form data set](https://html.spec.whatwg.org/multipage/forms.html#constructing-form-data-set) algorithm.
+* Fixed all constructors that appears as globals on the jsdom `window` object to be non-enumerable.
+* Fixed `<script>` elements to load when they gain a `src` attribute while in a document.
+* Fixed `<link rel="stylesheet">` elements to load when their `href` attributes change while in a document.
+* Fixed the loading of external `<img>`s (when the `canvas` npm package is installed) that were specified via relative URL; this regressed in 9.2.1.
+* Fixed `<iframe>` documents to have the correct `referrer` value (viz. the URL of their parent).
+* Fixed the value of `input.checked` inside `click` events on checkboxes.
+* Fixed the window object's named properties to correctly return the `<iframe>` element or the `<iframe>`'s window in appropriate scenarios involving `name` vs. `id` attributes on the `<iframe>`. (matthewp)
+
+## 9.3.0
+
+* Added the `Audio` named constructor.
+* Fixed the `Image` named constructor to follow the spec more closely (e.g. `Image.prototype` is now equal to `HTMLImageElement.prototype`).
+* Fixed the `tabIndex` setter, which regressed in 9.1.0, to no longer cause errors.
+* Made submit buttons and labels respond to click event cancelation correctly, preventing form submission and re-dispatching to the relevant form control. (marcandre)
+* Fixed unhandled errors thrown in XHR event handlers being swallowed; they now properly are redirected to the virtual console.
+
+## 9.2.1
+
+* Fixed `<input>`'s `selectionStart`, `selectionEnd`, and `selectionDirection` getters to return null, instead of throwing, for elements that do not allow selection, per [a recent spec change](https://github.com/whatwg/html/pull/1006).
+* Fixed `<base>`'s `href` getter logic to return the attribute value instead of the empty string for unparseable URLs, per [a recent spec change](https://github.com/whatwg/html/pull/1064).
+* Fixed the referrer sent when retrieving external resources to be the document's URL, not the document's base URL.
+* Fixed suppression of all `error` events on `window` beyond the first one.
+* Fixed `new URL` to correctly throw for unparseable URLs, and all of `URL`'s setters to correctly ignore invalid input instead of throwing.
+* Fixed `StyleSheetList.prototype.item` to return `null` instead of `undefined` for out-of-bounds indices. (Ginden)
+* Updated `cssstyle` minimum version to ensure all jsdom installs (not just fresh ones) get the benefit of `cssstyle`'s recently-better `background` and `width` setters.
+
+## 9.2.0
+
+* Added `jsdom.changeURL(window, newURL)` for allowing you to override a window's existing URL. (mummybot)
+* Fixed the `proxy` option to be applied to all requests; previously it was not always passed through. (nicolashenry)
+* Fixed `XMLHttpRequest` response header filtering for cross-origin requests; this also fixes `ProgressEvent`s fired from such XHRs. (nicolashenry)
+
+## 9.1.0
+
+* Added a somewhat-reasonable implementation of focus and focus events. Although the full complexity of focus is not implemented, the following improvements have been made:
+  - Only elements which are focusable can be focused.
+  - Added the `FocusEvent` class, and now `focus` and `blur` events are fired appropriately.
+  - `tabIndex` now returns `0` by default for focusable elements.
+* Reimplemented `navigator` to be to-spec:
+  - Added `appCodeName`, `product`, `productSub`, `vendor`, and `vendorSub`; also changes `userAgent`, `appName`, `platform`, and `version` to be more browser-like instead of based on various Node.js information.
+  - Added `language` and `languages`.
+  - Added `onLine`.
+  - Added `javaEnabled()`.
+  - Removed `noUI`.
+* Fixed `formEl.action` to return a value resolved relative to the document URL, or to return the document URL if the corresponding attribute is missing or empty.
+* Sped up XPath execution. (vsemozhetbyt)
+* Fixed `window.close()` not correctly clearing event listeners on the document. (Ojek)
+* Fixed a regression introduced in v9.0.0 where invalid CSS would cause a crash while attempting to parse it. Instead, a `"jsdomError"` will now be emitted to the virtual console.
+
+## 9.0.0
+
+This major release removes jsdom's support for mutation events. Mutation events were never well-specified, and the modern DOM Standard omits them in the hopes that they can be removed from browsers (although this has not yet happened in major browser engines). We had hoped to implement their modern alternative, mutation observers, before performing this removal, to give jsdom users the same capabilities.
+
+However, recent performance investigations revealed that mutation events were the major bottleneck in most jsdom operations; tools like [ecmarkup](https://github.com/bterlson/ecmarkup) which make heavy use of jsdom had their running time halved by removing mutation events, which add serious overhead to every DOM mutation. As such, we are doing a major release with them removed, so that jsdom users can benefit from this massive performance gain.
+
+Mutation observer support is [in progress](https://github.com/jsdom/jsdom/issues/639); please use the GitHub reactions feature to vote on that issue if you are impacted by this removal and are hoping for mutation observer support to replace it.
+
+Your normal change log follows:
+
+* **Removed mutation events**, as discussed above.
+* Added the `DOMTokenList.prototype.replace` method. (nicolashenry)
+* Updated `DOMTokenList.prototype.contains` to no longer validate its arguments, as per the latest spec. (nicolashenry)
+* Made various improvements to XMLHttpRequest (nicolashenry):
+  - Added the `responseURL` property.
+  - Updated methods, headers, and header values to use the `ByteString` algorithm.
+  - Fixed the default `statusText` to be `""` instead of `"OK"`.
+* Fixed the `Blob` constructor's `type` validation. (nicolashenry)
+
+## 8.5.0
+
+* Added encoding handling (nicolashenry)
+  - `jsdom.env`, when given a URL or file, will decode the resulting bytes using signals like the `Content-Type` header, `<meta charset>` declaration, or presence of a BOM, in the same manner as web browsers.
+  - Fetching external resources, via mechanisms such as XMLHttpRequest or `<script>`/`<link>`/`<iframe>` tags, will also account for such signals.
+  - `jsdom.jsdom()`, which takes a string, still sets a "UTF-8" encoding by default, since there are no bytes or headers for it to sniff an encoding from.
+* Removed `iframe.sandbox` property, since it was not implemented and simply crashed when used.
+* Removed `element.sourceIndex` property, since it was nonstandard (Internet Explorer only).
+* Fixed setting proxied inline event handlers, such as `doc.body`'s `onload=""` attribute, for documents that do not have a browsing context.
+
+## 8.4.1
+
+* Fixed an issue where setting `selected` on an multi-select would clear all other selectedness.
+
+## 8.4.0
+
+* Added an implementation of the `TreeWalker` class (and `document.createTreeWalker`). (garycourt)
+* Fixed a few minor bugs in URL parsing and the `URL` API, by upgrading to `whatwg-url` v2.0.1.
+* Fixed a few issues with generated files in the published package, which seem to have impacted webpack users.
+
+## 8.3.1
+
+* Fixed an issue where if you modified `Object.prototype`, spurious attributes would show up on your jsdom nodes. (deckar01)
+
+## 8.3.0
+
+* Added image loading and decoding, when the `canvas` npm package is installed (lehni). In practice, this means that if you enable fetching `"img"` external resources, then:
+  * `img.naturalWidth`, `img.naturalHeight`, `img.width`, `img.height`, `img.complete`, and `img.currentSrc` will update themselves correctly as the image loads
+  * `load` and `error` events will fire on the `<img>` element, according to how well image decoding goes.
+  * You can draw images onto canvases, using the newly-enabled `canvasContext.drawImage` API.
+* Added `canvasContext.createPattern` and `canvasContext.toBlob`, when the `canvas` npm package is installed. (lehni)
+* Added a basic implementation of the [Page Visibility API](https://w3c.github.io/page-visibility/), in particular a `document.hidden` property that always returns `true`, and a `document.visibilityState` property that always returns `"prerender"`. This is a more standard alternative to our proprietary `navigator.noUI`, which will be removed whenever we release v9.0.0. (kapouer)
+
+## 8.2.0
+
+* Added correct click behavior for inputs (jeffcarp):
+  - `change` and `input` events now fire appropriately
+  - The "click in progress" flag is implemented, so you cannot click while a click is in progress
+  - Canceling a click event appropriately resets radio buttons and checkboxes
+* Updated our XMLHttpRequest implementation with a variety of fixes and features, including preliminary CORS support. (nicolashenry)
+* Added a `strictSSL` top-level option to govern all requests jsdom makes. (nicolashenry)
+* XHTML frames and iframes are now parsed as XML instead of HTML. (nicolashenry)
+* Added `document.origin` and `document.lastModified`. (nicolashenry)
+* Fixed the `scriptEl.text` getter and setter to follow the spec.
+* Fixed script execution to check against the canonical list of JavaScript MIME types and only execute those scripts as JavaScript.
+
+## 8.1.1
+
+* Fixed input selection methods and properties to properly differentiate between inputs that can be selected outright vs. textual inputs which allow variable-length selection. (yaycmyk)
+
+## 8.1.0
+
+* Added `attr.nodeName`, which was [recently re-added to the spec](https://github.com/whatwg/dom/issues/171).
+* Added click-proxying behavior from `<label>`s to their labeled form elements. (yaycmyk)
+* Added a setter for `element.classList` per recent spec changes (it forwards to `element.classList.value`).
+* Updated our attributes implementation in a few ways for recent spec changes and to fix discovered bugs:
+  - Added `element.getAttributeNames()`. ([spec addition](https://github.com/whatwg/dom/issues/115))
+  - `setAttributeNode` and `setAttributeNodeNS` can now replace an attribute node, instead of removing the old one and adding a new one; this avoids changing the order in the attribute list. ([spec change](https://github.com/whatwg/dom/issues/116))
+  - `NamedNodeMap` named properties are now lowercase (except in edge cases involving XML documents or non-HTML elements). ([spec change](https://github.com/whatwg/dom/issues/141))
+  - `NamedNodeMap` named properties are now non-enumerable.
+  - The `"DOMAttrModified"` mutation event's `relatedNode` is now the new `Attr` object, not the `Node`, as per spec.
+* Updated `DOMTokenList` to have a `value` property per [recent spec changes](https://github.com/whatwg/dom/issues/119); its `toString` serialization also changed slightly.
+* Updated `tc.headers` to be a `DOMTokenList` that simply reflects the `headers` attribute; previously it was a string, with its computation doing some weird stuff.
+* Fixed `document.implementation.createDocument()` to create a document with its parsing mode set to XML, which affects a variety of DOM APIs in small ways.
+* Fixed `EventTarget.prototype.constructor` to be correct; it was previously `Window`.
+* Fixed `option.index` for `<option>`s not inside a `<select>` to no longer error.
+* Fixed `tc.cellIndex` for `<td>`s and `<th>`s not inside a `<tr>` to no longer error.
+* Fixed `tr.sectionRowIndex` for `<tr>`s not inside a `<table>`, `<tbody>`, `<thead>`, or `<tfoot>` to no longer error.
+* Removed the `"keyevents"` alias for `"keyboardevent"` when using `document.createEvent`, [per recent spec changes](https://github.com/whatwg/dom/issues/148).
+
+## 8.0.4
+
+* Fixed the `this` value when you pass a `{ handleEvent() { ... } }` object to `addEventListener`. (thetalecrafter)
+
+## 8.0.3
+
+* Fixed `HTMLOptionElement.prototype.label`; a typo was causing it to not work at all. (karlhorky)
+* Updated `cssstyle` minimum version to ensure all jsdom installs (not just fresh ones) get the benefit of `cssstyle`'s recently-better `padding` and `margin` parsing/CSSOM.
+
+## 8.0.2
+
+* Fixed an issue where custom user agents would not propagate to `navigator.userAgent` in frames and iframes.
+* Improved our `document.activeElement` implementation to be a bit smarter; we still don't have full focus/blur/active element semantics, but at least now it falls back to the `<body>` element when the active element is removed from the document or when no element has been focused yet.
+
+## 8.0.1
+
+* Fixed an issue where the `this` inside event handler callbacks was not equal to the event's current target. (Surprisingly there were no tests for this!)
+
+## 8.0.0
+
+This major release includes a large rewrite of most of the DOM and HTML classes exposed in jsdom. A lot of their behavior is generated from their specs' IDL syntax, taking care of many type conversions, attribute/property reflections, and much more. Many properties that were previously not present are now available, and almost everything behaves in a more spec-compliant way. Additionally, for these classes all of their implementation details are no longer available as underscore-prefixed properties, but instead are hidden behind a single symbol.
+
+Although normally jsdom does not mark a new major release for changes that simply update us to the latest specs or hide internal implementation details better, the magnitude of the changes is so extensive that we want to bump the major version in order to ensure that consumers perform adequate testing before upgrading. But, you should definitely upgrade! The new stuff is really awesome!
+
+* Reimplemented `Location`, `History`, and `HTMLHyperlinkElementUtils` (used by both `HTMLAnchorElement` and `HTMLAreaElement`) according to the latest specs, and using the latest [whatwg-url](https://github.com/jsdom/whatwg-url) package. This greatly improves our correctness on URL resolution and navigation (to the extent we support navigation, i.e. `pushState` and changing the hash). It should also improve parsing speed as we no longer parse and resolve URLs during parsing.
+* Added `Element.prototype.insertAdjacentHTML`. (kasperisager)
+* Added `Node.prototype.adoptNode`, and adopt nodes during insertion instead of throwing `"WrongDocumentError"`s. (dmethvin)
+* Added a stub `Element.prototype.getClientRects` to match our stub `getBoundingClientRect`.
+* Fixed `setTimeout` and `setInterval` to return numeric IDs, instead of objects. (alvarorahul)
+* Fixed `setTimeout` and `setInterval` to accept string arguments to eval, and to pass along extra arguments after the first two.
+* Fixed certain style shorthand properties not updating their component properties or parsing correctly. (dpvc)
+* Fixed `Event` object creation to always initialize the event objects, unless using `document.createEvent`, even for events with name `""`.
+* Fixed iframes to go through the custom resource loader. (chrmarti)
+* Removed ["DOM Load and Save"](http://www.w3.org/TR/2003/CR-DOM-Level-3-LS-20031107/load-save.html) stub implementation. That spec was never implemented in browsers, and jsdom only contained stubs.
+* Removed other minor unimplemented, stub, or no-longer-standard APIs from "DOM Level 3", like the user-data API, `DOMError`, `DOMConfiguration`, and `DOMStringList`.
+
+## 7.2.2
+
+* Fixed `canvasEl.toDataURL()`, with the `canvas` npm package installed; a recent update to the `canvas` package broke how we were passing arguments to do.
+* Fixed `data:` URL parsing to allow empty contents, e.g. `data:text/css;base64,`. (sebmck)
+
+## 7.2.1
+
+* Fixed a regression in XML parsing of attributes with a namespace URL but no prefix (e.g. `<math xmlns="http://www.w3.org/1998/Math/MathML">`).
+
+## 7.2.0
+
+* Added support for text selection APIs on `<input>` and `<textarea>`! (sjelin and yaycmyk)
+* Replaced our default XML parser with [sax](https://www.npmjs.com/package/sax), thus fixing many (but not all) issues with XML and XHTML parsing. To get a flavor of the issues fixed, check out these now-closed bugs: [#393](https://github.com/jsdom/jsdom/issues/393), [#651](https://github.com/jsdom/jsdom/issues/651), [#415](https://github.com/jsdom/jsdom/issues/415), [#1276](https://github.com/jsdom/jsdom/issues/1276).
+* Fixed the `<canvas>` tag to reset its contents when its width or height changed, including the change from the default 300 × 150 canvas. (Applies only when using the `canvas` npm package.)
+* Fixed an issue where `HTMLCollection`s would get confused when they contained elements with numeric `id`s or `name`s.
+* Fixed an issue with doctype parsing confusing the system ID and public ID.
+* Made the task posted by `postMessage` use the inside-jsdom timer queue, instead of the Node.js one. This allows easier mocking. (cpojer)
+
+## 7.1.1
+
+* When `<iframe>`s have unresolvable URLs, jsdom will no longer crash, but will instead just load `about:blank` into them. (This is the spec behavior.)
+* Fixed `document.writeln` to correctly handle multiple arguments; previously it ignored all after the first.
+* Fixed `FileList` objects to no longer have a property named `"undefined"`. (jfremy)
+
+## 7.1.0
+
+This is a rather large release bringing with it several important re-implementations of DOM and HTML APIs.
+
+* Our `EventTarget` implementation has been rewritten from scratch to follow the spec exactly. This should improve any edge case misbehaviors.
+* Our `Event` class hierarchy has been rewritten and fleshed out, fixing many gaps in functionality.
+  - Previously missing classes `KeyboardEvent` and `TouchEvent` are now implemented.
+  - Almost all supported `Event` subclasses now have constructors. (`TouchEvent` does not yet, and `MutationEvent` is specified to not have one.)
+  - All classes now have correct public APIs, e.g. getters instead of data properties, missing properties added, and constructors that correctly allow setting all the supported properties.
+  - `document.createEvent("customevent", ...)` now correctly creates a `CustomEvent` instead of an `Event`, and `CustomEvent.prototype.initProgressEvent` has been replaced with `CustomEvent.prototype.initCustomEvent`.
+* The `Attr` class and related attribute-manipulating methods has been rewritten to follow the latest specification. In particular, `Attr` is no longer a subclass of `Node`, and no longer has child text nodes.
+* The `<template>` element implementation has been greatly improved, now passing most web platform tests. Its `.content` property no longer has an extra intermediate document fragment; it no longer has child nodes; and related parts of the parser and serializer have been fixed, including `innerHTML` and `outerHTML`, to now work as specified.
+* `querySelector`, `querySelectorAll`, and `matches` now correctly throw `"SyntaxError"` `DOMException`s for invalid selectors, instead of just `Error` instances.
+* `Node.prototype`'s `insertBefore`, `replaceChild`, and `appendChild` methods now check their arguments more correctly.
+* The browser builds now have regained the ability to fetch URLs for content and the like; this had been broken due to an issue with the browser-request package, which is no longer necessary anyway.
+
+## 7.0.2
+
+* Fixed an issue where inside jsdom `<script>` code, `/regexpliteral/ instanceof RegExp` would be `false`.
+
+## 7.0.1
+
+* Fixed two bugs with `Node.prototype.isEqualNode`:
+  - It would previously always return `true` for comparing any two doctypes.
+  - It would throw an error when trying to compare two elements that had attributes.
+* Enforced that `document.implementation.createDocumentType` requires all three of its arguments.
+
+## 7.0.0
+
+This major release has as its headlining feature a completely re-written `XMLHttpRequest` implementation, in a heroic effort by [@nicolashenry](https://github.com/nicolashenry). It includes a number of other smaller improvements and fixes. The breaking changes are highlighted in bold below.
+
+* **Node.js 4.0 onward is now required**, as we have begun using ES2015 features only present there.
+* Completely re-implemented `XMLHttpRequest` and related classes (nicolashenry):
+  - Includes support for `Blob`, `File`, `FileList`, `FileReader`, `FormData`, `ProgressEvent`, and the supporting `XMLHttpRequestUpload`, and `XMLHttpRequestEventTarget` interfaces.
+  - Includes support for synchronous XHRs.
+  - Adds some new request-management abilities, documented in the readme. In short, the `pool`, `agentOptions`, and `userAgent` options are new, and resource loads can now be aborted.
+  - These implementations are extremely complete and standards-compliant, passing 136 newly-introduced web platform tests.
+* Added `document.charset`, an alias for `document.characterSet`.
+* Added `HTMLTemplateElement.prototype.content`, for getting the contents of a `<template>` element as a document fragment. (rickychien)
+* Implemented "loose" cookie parsing, giving correct execution of code like `document.cookie = "foo"`.
+* Several fixes related to event dispatching and creation, including the addition of `Event.prototype.stopImmediatePropagation` and the constants `NONE`, `CAPTURING_PHASE`, `AT_TARGET`, and `BUBBLING_PHASE`. This accounted for another 15 newly-passing web platform tests. (nicolashenry)
+* Fixed `document.styleSheets` to correctly track the removal of stylesheets from the document. (AVGP)
+* Fixed the `created` jsdom lifecycle callback receiving a different `window` object than the `loaded` or `done` callbacks when scripting was enabled.
+* **Invalid URLs are no longer allowed when creating a jsdom document**; the URL must be parseable, or an error will be thrown.
+* **The `{ omitJsdomErrors }` option of the virtual console has moved**; it is no longer provided when creating the virtual console, but instead when calling `sendTo`.
+
+## 6.5.1
+
+* Fixed an issue where with `jsdom.jsdom`, you had to pass `referrer` and `cookie` options as top-level, whereas with `jsdom.env`, you had to nest them under a `document` option. This was unnecessarily confusing. Now both possibilities are allowed for both functions. (The readme only documents the top-level version, though.)
+
+## 6.5.0
+
+* Added `NodeList.prototype[Symbol.iterator]`, so you can now use `for`-`of` loops with `NodeList`s.
+
+## 6.4.0
+
+* Added `jsdom.nodeLocation(node)` to get the location within the source text of a given node.
+* Added `jsdom.reconfigureWindow(window, { top })` to allow changing the value of a window's `top` property.
+* Added the `element` argument to the custom resource loader, so you can customize resource loads depending on which element loaded them.
+* Updated `getElementsByClassName` to match the spec. It now correctly splits on whitespace to try to find elements with all the given classes; it returns a `HTMLCollection` instead of a `NodeList`; and it memoizes the result.
+* Updated `NodeList` and `HTMLCollection` to match the spec. The most noticable change is that `HTMLCollection` no longer inherits from `NodeList`.
+
+## 6.3.0
+
+* Added a fully spec-compliant implementation of `window.atob` and `window.btoa`. (jeffcarp)
+* Fixed many issues with our `<canvas>` implementation:
+  - With the `canvas` npm package installed, `<canvas>` elements are now properly `instanceof HTMLCanvasElement` and `instanceof HTMLElement`.
+  - `<canvas>` elements now present the same uniform spec-compliant API both with and without the `canvas` npm package installed. If the package is not installed, some of the methods will cause not-implemented `jsdomError` events to be emitted on the virtual console.
+  - The `width` and `height` properties now correctly reflect the `width` and `height` attributes, and have the appropriate default values of `300` and `150`.
+  - With the `canvas` npm package installed, `<canvas>` elements now generally play better with other parts of jsdom, e.g., `document.getElementById` actually works with them.
+* Introduced and upated many of our element classes, so that at least every tag name/element class pair is now correct, even if some of the classes are stubs. In particular:
+  - Complete implementations were added for `HTMLDataElement`, `HTMLSpanElement`, and `HTMLTimeElement`.
+  - Stubs were added for `HTMLDataListElement`, `HTMLDialogElement`, `HTMLEmbedElement`, `HTMLMeterElement`, `HTMLOutputElement`, `HTMLProgressElement`, `HTMLSourceElement`, `HTMLTemplateElement`, and `HTMLTrackElement`.
+  - `HTMLAudioElement` was implemented in full, although its `HTMLMediaElement` base, where most of its functionality is, is still largely a stub.
+  - `HTMLTableSectionElement`, `HTMLTableRowElement`, `HTMLTableCellElement`, `HTMLTableDataCellElement`, and `HTMLTableHeaderCellElement` were updated to the latest spec.
+  - `HTMLIsIndexElement` was removed; it has never been produced by the parser since 1.0.0-pre.1, and so it has been just a vestigial global property.
+  - Appropriate constants were added to `HTMLMediaElement`.
+* Updated everything having to do with base URLs to be per-spec:
+  - Added `Node.prototype.baseURI` property to get the node's owner document's base URL.
+  - `HTMLBaseElement`'s `href` getter now contains appropriate fallbacks and always returns an absolute URL, per spec.
+  - If there are no `base` elements in an `"about:blank"` iframe document, the base URL correctly falls back to the parent window's base URL.
+* When you provide a `url: ...` option to `jsdom.jsdom()` or `jsdom.env()`, the given string is now attempted to be resolved as a URL before it is installed as `document.URL`.
+  - So for example, providing `url: "http://example.com"` will mean `document.URL` returns `"http://example.com/"`, with a trailing slash.
+  - In a future major release, we will start throwing if strings that cannot be parsed as valid absolute URL are provided for this option.
+
+## 6.2.0
+
+* Added a full-featured, spec-compliant `Element.prototype.classList`, closing out a three-year old issue! (wacii)
+* Made `virtualConsole.sendTo(console)` forward `"jsdomError"`s to `console` by calling `console.error`. This can be turned off by doing `virtualConsole.sendTo(console, { omitJsdomErrors: true })`.
+* Fixed errors when trying to parse invalid doctype declarations, like `<!DOCTYPE>`.
+* Fixed spurious `"jsdomError"`s that were emitted after calling `window.close()`.
+* Fixed the `DOMSubtreeModified` event to fire in more cases. Note that our mutation events implementation remains incomplete, and will eventually be removed (in a major release) once we implement mutation observers. (selam)
+
+## 6.1.0
+
+* Added basic implementations of `HTMLMediaElement` and `HTMLVideoElement`, back-ported from Facebook's Jest project. (cpojer)
+
+## 6.0.1
+
+* Fixed `XMLHttpRequest.prototype.getAllResponseHeaders` to not crash when used with `file:` URLs. (justinmchase)
+* Fixed `XMLHttpRequest.prototype.response` to correctly return the response text even when `responseType` was unset. (justinmchase)
+
+## 6.0.0
+
+This major release is focused on massive improvements in speed, URL parsing, and error handling. The potential breaking changes are highlighted in bold below; the largest ones are around the `jsdom.env` error-handling paradigm.
+
+This release also welcomes [long-time contributer](https://github.com/jsdom/jsdom/commits/master?author=Joris-van-der-Wel) [@Joris-van-der-Wel](https://github.com/Joris-van-der-Wel/) to the core team. You may recognize him from earlier changelogs. We're very happy to have his help in making jsdom awesome!
+
+* **io.js 2.0 onward is now required**, as we have begun using ES2015 features only present there.
+* Improved performance dramatically, by ~10000x in some cases, due to the following changes:
+  - Overhauled the named properties tracker to not walk the entire tree, thus greatly speeding up the setting of `id` and `name` attributes (including during parsing).
+  - Overhauled everything dealing with tree traversal to use a new library, [symbol-tree](https://github.com/jsdom/js-symbol-tree), to turn many operations that were previously O(n^2) or O(n) into O(n) or O(1).
+  - Sped up `node.compareDocumentPosition` and anything that used it (like `node.contains`) by doing more intelligent tree traversal instead of directly implementing the specced algorithm.
+* Overhauled how error handling works in jsdom:
+  - `window.onerror` (or `window.addEventListener("error", ...)`) now work, and will catch all script errors, similar to in browsers. This also introduces the `ErrorEvent` class, incidentally.
+  - The virtual console is now the destination for several types of errors from jsdom, using [the new event `"jsdomError"`](https://github.com/jsdom/jsdom#virtual-console-jsdomerror-error-reporting). This includes: errors loading external resources; script execution errors unhandled by `window.onerror`; and not-implemented warnings resulting from calling methods like `window.alert` which jsdom explicitly does not support.
+  - Since script errors are now handled by `window.onerror` and the virtual console, they are no longer included in the initialization process. This results in two changes to `jsdom.env` and the initialization lifecycle:
+    + **The `load(errors, window)` callback was changed to `onload(window)`**, to reflect that it is now just sugar for setting a `window.onload` handler.
+    + **The `done(errors, window)` callback (i.e., the default callback for `jsdom.env`) has become `done(error, window)`**, and like every other io.js callback now simply gives you a single error object, instead of an array of them.
+  - Nodes no longer have a nonstandard `errors` array, or a `raise` method used to put things in that array.
+* URL parsing and resolution was entirely overhauled to follow [the URL standard](http://url.spec.whatwg.org/)!
+  - This fixes several long-standing bugs and hacks in the jsdom URL parser, which already had a mess of gross patches on top of the built-in io.js parser to be more web-compatible.
+  - The new [`URL` class](https://url.spec.whatwg.org/#url) has been added to `window`
+  - The interfaces for `HTMLAnchorElement.prototype` and `document.location` (as well as `URL`, of course) are now uniformized to follow the [`URLUtils` API](https://url.spec.whatwg.org/#api) (minus `searchParams` for now).
+  - **As part of this change, you may need to start passing in `file:` URLs to `jsdom.env` where previously you were able to get away with passing in filenames.**
+* Added the `XMLHttpRequest.prototype.response` getter.
+* Fixed `StyleSheetList.prototype.item` to actually work. (chad3814)
+* Fixed the browser `vm` shim to properly add the built-in global properties (`Object`, `Array`, etc.) to the sandbox. If you were running jsdom inside a web worker and most of your scripts were broken, this should fix that.
+* Fixed the `hashchange` event to correctly fire `HashChangeEvent` instances, with correct properties `newURL` and `oldURL` (instead of the incorrect `newUrl` and `oldUrl` used previously).
+* Removed usage of the setimmediate library, as it required `eval` and thus did not work in CSP scenarios.
+
+Finally, if you're a loyal jsdom fan whose made it this far into the changelog, I'd urge you to come join us in [#1139](https://github.com/jsdom/jsdom/issues/1139), where we are brainstorming a modernized jsdom API that could get rid of many of the warts in the current one.
+
+## 5.6.1
+
+* Fixed an accidentally-created global `attribute` variable if you ever called `createAttributeNS`.
+* Dependency upgrades fixed a couple of bugs, although you would have gotten these anyway with a clean jsdom v5.6.0 install:
+  - Parsing of CSS properties that use `url("quoted string")` now works correctly, as of `cssstyle` v0.2.29.
+  - Selectors for the empty string, like `div[title=""]`, now work correctly, as of `nwmatcher` v1.3.6.
+
+## 5.6.0
+
+* `virtualConsole.sendTo` now returns `this`, allowing for [a nice shorthand](https://github.com/jsdom/jsdom/tree/60ccb9b318d0bae8fe37e19af5af444b9c98ddac#forward-a-windows-console-output-to-the-iojs-console). (jeffcarp)
+
+## 5.5.0
+
+* Added `postMessage` support, for communicating between parent windows, iframes, and combinations thereof. It's missing a few semantics, especially around origins, as well as MessageEvent source. Objects are not yet structured cloned, but instead passed by reference. But it's working, and awesome! (jeffcarp)
+* Rewrote cloning code (underlying `cloneNode` and `importNode`), fixing a number of issues:
+  - Elements with weird tag names, of the type that only the parser can normally create, can now be cloned ([#1142](https://github.com/jsdom/jsdom/issues/1142))
+  - Doctypes can now be cloned, per the latest spec.
+  - Attrs cannot be cloned, per the latest spec (although they still have a `cloneNode` method for now due to legacy).
+  - Document clones now correctly copy over the URL and content-type.
+* Fixed any virtual console output from iframes to be proxied to the parent window's virtual console. (jeffcarp)
+* Fixed the `type` property of `<button>` elements to correctly default to `submit`, and to stay within the allowed range.
+* Fixed clicking on submit `<button>`s to submit their containing form; previously only `<input type="submit">` worked. (rxgx)
+* Fixed `document.open()` to return `this`, per spec. (ryanseddon)
+
+Additionally, Joris-van-der-Wel added [a benchmarking framework](https://github.com/jsdom/jsdom/blob/master/Contributing.md#running-the-benchmarks), and a number of benchmarks, which should help us avoid performance regressions going forward, and also make targeted performance fixes. We're already investigating [some real-world issues](https://github.com/jsdom/jsdom/issues/1156) using this framework. Very exciting!
+
+## 5.4.3
+
+* Incorporated upstream fix for setting `el.style.cssText` to an invalid value, which should be ignored instead of causing an error to be thrown. This same bug has also caused an error while setting the style attribute to an invalid value, ever since 5.4.0. (Joris-van-der-Wel; chad3814 upstream)
+
+## 5.4.2
+
+* Fixed license metadata to conform to latest npm standards.
+
+## 5.4.1
+
+* Fixed to work with browserify again (regression introduced in v5.4.0).
+
+## 5.4.0
+
+This is a pretty exciting release! It includes a couple features I never really anticipated jsdom being awesome enough to have, but our wonderful contributors powered through and made them happen anyway:
+
+* Added support for the default HTML stylesheet when using `window.getComputedStyle`! (akhaku)
+  - Notably, this makes jQuery's `show()` and `hide()` methods now work correctly; see [#994](https://github.com/jsdom/jsdom/issues/994).
+* Added support for named properties on `window`: any elements with an `id` attribute, or certain elements with a `name` attribute, will cause properties to show up on the `window`, and thus as global variables within the jsdom. (Joris-van-der-Wel)
+  - Although this is fairly unfortunate browser behavior, it's standardized and supported everywhere, so the fact that jsdom now supports this too means we can run a lot of scripts that would previously fail.
+  - Previously, we only supported this for `<iframe>`s, and our implementation was quite buggy: e.g., `<iframe name="addEventListener">` would override `window.addEventListener`.
+  - Now that we have the infrastructure in place, we anticipate expanding our support so that this works on e.g. `HTMLFormElement`s as well in the future.
+
+We also have a bunch more fixes and additions:
+
+* Implemented the [`NonDocumentTypeChildNode`](https://dom.spec.whatwg.org/#nondocumenttypechildnode) mixin. Practically, this means adding `nextElementSibling` and `previousElementSibling` to `Element` and the various types of `CharacterData`. (brandon-bethke-neudesic)
+* Updated `StyleSheetList` to inherit from `Array`, as per the latest CSSOM spec.
+* Overhauled the handling of attributes throughout the DOM, to follow the spec more exactly.
+  - Our `NamedNodeMap` implementation is up to date, as are the various `Element` methods; other places in the code that deal with attributes now all go through a spec-compliant set of helpers.
+  - Some weirdnesses around the `style` attribute were fixed along the way; see e.g. [#1109](https://github.com/jsdom/jsdom/issues/1109).
+  - However, `Attr` objects themselves are not yet spec-compliant (e.g., they still inherit from `Node`). That's coming soon.
+* Fixed an unfortunate bug where `getElementById` would fail to work correctly on `<img>` elements whose `id` attributes were modified. (Joris-van-der-Wel)
+* Fixed the `virtualConsole` option to work with `jsdom.env`, not just `jsdom.jsdom`. (jeffcarp)
+* Removed a few functions that were erroneously added to `window`: `mapper`, `mapDOMNodes`, and `visitTree`. (Joris-van-der-Wel)
+
+## 5.3.0
+
+* Added a `virtualConsole` option to the document creation methods, along with the `jsdom.createVirtualConsole` factory. (See [examples in the readme](https://github.com/jsdom/jsdom/blob/dbf88666d1152576237ed1c741263f5516bb4005/README.md#capturing-console-output).) With this option you can install a virtual console before the document is even created, thus allowing you to catch any virtual console events that occur during initialization. (jeffcarp)
+
+## 5.2.0
+
+* Implemented much of the [`ParentNode`](https://dom.spec.whatwg.org/#interface-parentnode) mixin (Joris-van-der-Wel):
+  - Moved `children` from `Node` to `ParentNode`, i.e., made it available on `Document`, `DocumentFragment`, and `Element`, but not other types of nodes.
+  - Made `children` a `HTMLCollection` instead of a `NodeList`.
+  - Implemented `firstElementChild`, `lastElementChild`, and `childElementCount`.
+* Implemented the `outerHTML` setter. (Joris-van-der-Wel)
+* Fixed the `outerHTML` getter for `<select>` and `<form>`. (Joris-van-der-Wel)
+* Fixed various issues with window-less documents, so that they no longer give incorrect results or blow up in strange ways. You can create such documents with e.g. `document.implementation.createHTMLDocument()`. (Joris-van-der-Wel)
+* Fixed relative stylesheet resolution when using `@import`. (dbo)
+
+## 5.1.0
+
+* Added support for the `NodeIterator` class from the DOM Standard. (Joris-van-der-Wel)
+* Fixed an issue with the initial request where it was not sharing its cookie jar with the subsequent requests, sometimes leading to a "possible EventEmitter memory leak detected" warning. (inikulin)
+* Updated tough-cookie to 0.13.0, bringing along many spec compliance fixes. (inikulin)
+* Added a fast failure in Node.js™ with a clear error message, so that people don't get confused by syntax errors.
+
+## 5.0.1
+
+* Fixed `document.cookie` setter to no longer ignore `null`; instead it correctly sets a cookie of `"null"`. (Chrome is not compliant to the spec in this regard.)
+* Fixed documents created with `parsingMode: "xml"` to no longer get `"<html><head></head><body></body></html>"` automatically inserted when calling `jsdom.jsdom()` with no arguments.
+* Fixed the `innerHTML` setter to no longer ignore `undefined`; instead it correctly sets the innerHTML to `"undefined"`.
+* Fixed `document.write` to throw for XML documents as per the spec.
+* Fixed `document.write` to accept more than one argument (they get concatenated).
+* Fixed `document.write("")` to no longer try to write `"<html><head></head><body></body></html>"`.
+
+## 5.0.0
+
+This release overhauls how cookies are handled in jsdom to be less fiddly and more like-a-browser. The work for this was done by [@inikulin](https://github.com/inikulin), who is also our beloved parse5 maintainer.
+
+You should only need to worry about upgrading to this release if you use jsdom's cookie handling capabilities beyond the basics of reading and writing to `document.cookie`. If that describes you, here's what changed:
+
+* Removed `options.jar` and `options.document.cookieDomain` from the configuration for creating jsdom documents.
+* Instead, there is now a new option, `options.cookieJar`, which accepts cookie jars created by the new `jsdom.createCookieJar()` API. You should use this if you intend to share cookie jars among multiple jsdom documents.
+* Within a given cookie jar, cookie access is now automatically handled on a domain basis, as the browser does, with the domain calculated from the document's URL (supplied as `options.url` when creating a document). This supplants the former `options.document.cookieDomain`.
+
+In addition to these changes to the public API, the following new cookie-related features came along for the ride:
+
+* Implemented automatic cookie-jar sharing with descendant `<iframe>`s. (So, if the iframe is same-domain, it can automatically access the appropriate cookies.)
+* Let `options.document.cookie` accept arrays, instead of just strings, for if you want to set multiple cookies at once.
+
+Finally, it's worth noting that we now delegate our cookie handling in general to the [tough-cookie](https://www.npmjs.com/package/tough-cookie) package, which should hopefully mean that it now captures many of the behaviors that were previously missing (for example [#1027](https://github.com/jsdom/jsdom/issues/1027)). @inikulin is working on [a large pull request to fix tough-cookie to be more spec compliant](https://github.com/goinstant/tough-cookie/pull/30), which should automatically be picked up by jsdom installs once it is merged.
+
+## 4.5.1
+
+* Removed unnecessary browserify dependency that was erroneously included in 4.5.0.
+
+## 4.5.0
+
+* Added `document.currentScript`. (jeffcarp)
+
+## 4.4.0
+
+* All resources are now loaded with the [request](https://www.npmjs.com/package/request) package, which means that e.g. GZIPped resources will be properly uncompressed, redirects will be followed, and more. This was previously the case only for URLs passed directly to `jsdom.env`, and not for sub-resources inside the resulting page. (ssesha)
+
+## 4.3.0
+
+* Made the click behavior for radio buttons and checkboxes work when doing `el.dispatchEvent(clickEvent)`, not just when doing `el.click()`. (brandon-bethke-neudesic)
+* Added `defaultPrevented` property to `Event` instances, reflecting whether `ev.preventDefault()` has been called. (brandon-bethke-neudesic)
+* Moved the `click()` method from `HTMLInputElement.prototype` to `HTMLElement.prototype`, per the latest spec.
+* Made the `click()` method trigger a `MouseEvent` instead of just an `Event`.
+
+## 4.2.0
+
+* Added a second parameter to `UIEvent`, `MouseEvent`, and `MutationEvent`, which for now just behaves the same as that for `Event`. (Rich-Harris)
+
+## 4.1.0
+
+* Added a second parameter to the `Event` constructor, which allows you to set the `bubbles` and `cancelable` properties. (brandon-bethke-neudesic)
+
+## 4.0.5
+
+* Added `HTMLUnknownElement` and fix the parser/`document.createElement` to create those instead of `HTMLElement` for unknown elements.
+* Fixed issues with named and indexed properties on `window`, as well as `window.length`, with regard to `<frame>`s/`<iframe>`s being added and removed from the document.
+
+_Note:_ this probably should have been a minor version number increment (i.e. 4.1.0 instead of 4.0.5), since it added `HTMLUnknownElement`. We apologize for the deviation from semver.
+
+## 4.0.4
+
+* Fixed parsing of doctypes by relying on the information provided by the html parser if possible.
+
+## 4.0.3
+
+* Fixed events fired from `EventTarget`s to execute their handlers in FIFO order, as per the spec.
+* Fixed a case where `childNodes` would not be correctly up to date in some cases. (medikoo)
+* Sped up window creation with `jsdom.env` by ~600%, for the special case when no scripts are to be executed.
+
+## 4.0.2
+
+* `EventTarget` is now correctly in the prototype chain of `Window`.
+* `EventTarget` argument validation is now correct according to the DOM Standard.
+* `DOMException` now behaves more like it should per Web IDL. In particular it has a more comprehensive set of constants, and instances now have `name` properties.
+* `new Event("click")` can now be dispatched. (lovebear)
+* `document.createEvent` now behaves more like it should according to the DOM Standard: it accepts a wider range of arguments, but will throw if an invalid one is given. (lovebear)
+* Fixed a regression in our browser support that required Chrome 41 as of 4.0.1; now Chrome 40 will work, as well as (in theory, although less well-tested) the latest stable versions of Firefox and IE.
+
+## 4.0.1
+
+* Fixed: `Node.prototype.contains` to always return a boolean. This was a regression in 3.1.1. (Joris-van-der-Wel)
+* Fixed: `Document.prototype` no longer contains its own `ownerDocument` getter, instead correctly delegating to `Node.prototype`.
+* Fixed: some edge cases regarding running `<script>`s in browserified jsdom.
+* A couple fixes from updated dependencies (although you would have gotten these anyway with a fresh install, due to floating version specifiers):
+    - csstyle minimum version bumped from 0.2.21 to 0.2.23, fixing handling of `0` when setting numeric CSS properties and parsing of shorthand `font` declarations.
+    - parse5 minimum version bumped from 1.3.1 to 1.3.2 to, fixing the parsing of `<form>` elements inside `<template>` elements.
+
+## 4.0.0
+
+This release relies on the newly-overhauled `vm` module of io.js to eliminate the Contextify native module dependency. jsdom should now be much easier to use and install, without requiring a C++ compiler toolchain!
+
+Note that as of this release, jsdom no longer works with Node.js™, and instead requires io.js. You are still welcome to install a release in [the 3.x series](https://github.com/jsdom/jsdom/tree/3.x) if you are stuck on legacy technology like Node.js™.
+
+In the process of rewriting parts of jsdom to use `vm`, a number of related fixes were made regarding the `Window` object:
+
+* In some cases, state was implicitly shared between `Window` instances—especially parser- and serializer-related state. This is no longer the case, thankfully.
+* A number of properties of `Window` were updated for spec compliance: some data properties became accessors, and all methods moved from the prototype to the instance.
+* The non-standard `document.parentWindow` was removed, in favor of the standard `document.defaultView`. Our apologies for encouraging use of `parentWindow` in our README, tests, and examples.
+
+## 3.1.2
+
+* Some fixes to the `NOT_IMPLEMENTED` internal helper, which should eliminate the cases where calling e.g. `window.alert` crashes your application.
+* Fixed a global variable leak when triggering `NOT_IMPLEMENTED` methods, like `window.location.reload`.
+* Fixed the URL resolution algorithm to handle `about:blank` properly on all systems (previously it only worked on Windows). This is especially important since as of 3.0.0 the default URL is `about:blank`.
+* Fixed, at least partially, the ability to run `<script>`s inside a browserified jsdom instance. This is done by dynamically rewriting the source code so that global variable references become explicit references to `window.variableName`, so it is not foolproof.
+
+## 3.1.1
+
+* Updated `Node.prototype.isEqualNode` to the algorithm of the DOM Standard, fixing a bug where it would throw an error along the way.
+* Removed `Node.prototype.isSameNode`, which is not present in the DOM Standard (and was just a verbose `===` check anyway).
+* Fixed a couple small issues while browserifying, mainly around `jsdom.env`. However, while doing so discovered that `<script>`s in general don't work too well in a browserified jsdom; see [#1023](https://github.com/jsdom/jsdom/issues/1023).
+
+## 3.1.0
+
+* Added support for [custom external resource loading](https://github.com/jsdom/jsdom#custom-external-resource-loader). (tobie)
+
+## 3.0.3
+
+* Fixed some stray byte-order marks in a couple files, which incidentally [break Browserify](https://github.com/substack/node-browserify/issues/1095). (sterpe)
+
+## 3.0.2
+
+* Fixed another edge case where unchecking a radio button would incorrectly uncheck radio buttons outside the containing form. (zpao)
+
+## 3.0.1
+
+* Fixed errors when serializing text nodes (possibly only occurred when inside `<template>`).
+* Handle null bytes being passed to `jsdom.env`'s autodetecting capabilities. (fluffybunnies)
+* Handle empty HTML strings being passed to `jsdom.env`'s `html` option. (fluffybunnies)
+
+## 3.0.0
+
+This release updates large swathes of the DOM APIs to conform to the standard, mostly by removing old stuff. It also fixes a few bugs, introduces a couple new features, and changes some defaults.
+
+3.0.x will be the last release of jsdom to support Node.js. All future releases (starting with 4.0.0) will require [io.js](https://iojs.org/), whose [new `vm` module](https://github.com/iojs/io.js/blob/v1.x/CHANGELOG.md#vm) will allow us to remove our contextify native-module dependency. (Given that I submitted the relevant patch to joyent/node [1.5 years ago](https://github.com/joyent/node/commit/7afdba6e0bc3b69c2bf5fdbd59f938ac8f7a64c5), I'm very excited that we can finally use it!)
+
+* By default documents now use `about:blank` as their URL, instead of trying to infer some type of file URL from the call site (in Node.js) or using `location.href` (in browsers).
+* Introduced a new "virtual console" abstraction for capturing console output from inside the page. [See the readme for more information.](https://github.com/jsdom/jsdom#capturing-console-output) Note that `console.error` will no longer contribute to the (non-standard, and likely dying in the future) `window.errors` array. (jeffcarp)
+* Added the named `new Image(width, height)` constructor. (vinothkr)
+* Fixed an exception when using `querySelector` with selectors like `div:last-child > span[title]`.
+* Removed all traces of entities, entity types, notations, default attributes, and CDATA sections.
+* Differentiated between XML and HTML documents better, for example in how they handle the casing of tag names and attributes.
+* Updated `DOMImplementation` to mostly work per-spec, including removing `addFeature` and `removeFeature` methods, the `ownerDocument` property, and making `hasFeature` always return `true`.
+* Re-did the `CharacterData` implementation to follow the algorithms in the DOM Standard; this notably removes a few exceptions that were previously thrown.
+* Re-did `Comment`, `Text`, and `ProcessingInstruction` to follow the DOM Standard and derive from `CharacterData`.
+* Re-did `DocumentType` to follow the DOM Standard and be much simpler, notably removing notations, entities, and default attributes.
+* Fixed a variety of accessors on `Node`, `Element`, `Attr`, and `Document`; some were removed that were nonstandard (especially setters); others were updated to reflect the spec; etc.
+* Re-did name/qname validation, which is done by various APIs, to work with the xml-name-validator package and some centralized algorithms.
+* Made the XML parser at least somewhat aware of processing instructions.
+* Cleaned up doctype parsing and association between doctypes and documents. More exotic doctypes should parse better now.
+* `document.contentType` now is generally inferred from the parsing mode of the document.
+* Moved some properties to `Document.prototype` and `Window.prototype` instead of setting them as own properties during the document/window creation. This should improve memory usage (as well as spec compliance).
+
+## 2.0.0
+
+This release is largely a refactoring release to remove the defunct concept of "levels" from jsdom, in favor of the [living standard model](https://wiki.whatwg.org/wiki/FAQ#What_does_.22Living_Standard.22_mean.3F) that browsers follow. Although the code is still organized that way, that's now [noted as a historical artifact](https://github.com/jsdom/jsdom/blob/2ff5747488ad4b518fcef97a026c82eab42a0a14/lib/README.md). The public API changes while doing so were fairly minimal, but this sets the stage for a cleaner jsdom code structure going forward.
+
+* Removed: `jsdom.level`, and the `level` option from `jsdom.jsdom`.
+* Change: the nonstandard `Element.prototype.matchesSelector` method was replaced with the standard `Element.prototype.matches`. (KenPowers)
+* Fix: `querySelector` correctly coerces its argument to a string (1.2.2 previously fixed this for `querySelectorAll`).
+
+## 1.5.0
+
+* Add: missing `window.console` methods, viz. `assert`, `clear`, `count`, `debug`, `group`, `groupCollapse`, `groupEnd`, `table`, `time`, `timeEnd`, and `trace`. All except `assert` do nothing for now, but see [#979](https://github.com/jsdom/jsdom/issues/979) for future plans. (jeffcarp)
+* Tweak: make `childNodes`, and the many places in jsdom that use it, much faster. (Joris-van-der-Wel)
+
+## 1.4.1
+
+* Tweak: faster implementation of `NodeList.prototype.length`, which should speed up common operations like `appendChild` and similar. (Joris-van-der-Wel)
+
+## 1.4.0
+
+* Fix: `HTMLInputElement.prototype.checked` and `defaultChecked` now behave per the spec. (Joris-van-der-Wel)
+* Fix: `HTMLOptionElement.prototype.selected` now behaves per the spec. (Joris-van-der-Wel)
+* Fix: `HTMLInputElement.prototype.value` now behaves per the spec. (Joris-van-der-Wel)
+* Fix: `HTMLTextAreaElement.prototype.value` and `defaultValue` now behave per the spec. (Joris-van-der-Wel)
+* Add: `HTMLTextAreaElement.prototype.defaultValue` now has a setter, and `HTMLTextAreaElement.prototype.textLength` now exists. (Joris-van-der-Wel)
+* Fix: resetting a `<form>` now behaves per spec for all different types of form elements. (Joris-van-der-Wel)
+* Fix: radio buttons reset other radio buttons correctly now per the spec. (Joris-van-der-Wel)
+* Fix: `document.cloneNode` now works. (AVGP)
+* Fix: `hasAttribute` is now case-insensitive, as it should be. (AVGP)
+* Fix: `div.toString()` now returns `[object HTMLDivElement]`. (AVGP)
+
+## 1.3.2
+
+* Fix: check if `module.parent` exists before using it to construct a document's initial URL. Apparently some testing frameworks like Jest do not correctly emulate the module environment; this compensates. (SegFaultx64)
+
+## 1.3.1
+
+* Fix: changing attributes on `<option>` elements will now have the correct consequences. For example changing the `id` attribute now interacts correctly with `document.getElementById`. (Joris-van-der-Wel)
+
+## 1.3.0
+
+* Add: moved `focus` and `blur` methods to `HTMLElement.prototype`, instead of having them only be present on certain element prototypes. Our focus story is still not very spec-compliant, but this is a step in the right direction. (vincentsiao)
+
+## 1.2.3
+
+* Tweak: improve performance of `Node.prototype.insertBefore`, `Node.prototype.removeChild`, and several `AttributeList` methods. (Joris-van-der-Wel)
+
+## 1.2.2
+
+* Fix: `querySelectorAll` correctly coerces its argument to a string; notably this allows you to pass arrays. (jeffcarp)
+* Fix: the `data` setter on text nodes correctly coerces the new value to a string. (medikoo)
+* Fix: `document.toString()` now returns `[object HTMLDocument]`. (jeffcarp)
+
+## 1.2.1
+
+* Fix: handling of `<template>` element parsing and serialization, now that it is supported by parse5. (inikulin)
+
+## 1.2.0
+
+* Add: `NodeFilter`, in particular its constants. (fhemberger)
+* Fix: initial `history.length` should be `1`, not `0`. (rgrove)
+* Fix: `history.pushState` and `history.replaceState` should not fire the `popstate` event. (rgrove)
+
+## 1.1.0
+
+* Add: `document.implementation.createHTMLDocument()`. (fhemberger)
+* Fix: `localName` was sometimes `null` for elements when it should not be. (fhemberger)
+
+## 1.0.3
+
+* Update: no longer requiring separate `cssstyle` and `cssstyle-browserify` dependencies; now `cssstyle` can be used directly. This also un-pins the `cssstyle` dependency so that future fixes arrive as they appear upstream.
+
+## 1.0.2
+
+* Fix: temporarily pin `cssstyle` dependency to at most 0.2.18 until [chad3814/CSSStyleDeclaration#20](https://github.com/chad3814/CSSStyleDeclaration/issues/20) is fixed.
+* Fix: browserifying jsdom should work better now that the required packages are included as `dependencies` instead of `devDependencies`. (Sebmaster)
+* Fix: using `jsdom.env` in a browser environment now correctly defaults `options.url` to `location.href` instead of trying to infer a reasonable `fil://` URL using techniques that fail in the browser. (rattrayalex)
+
+## 1.0.1
+
+* Fix: the return value of `EventTarget.prototype.dispatchEvent` should be `true` when the default is *not* prevented; previously it was the opposite. (eventualbuddha)
+
+## 1.0.0
+
+For a consolidated list of changes from 0.11.1 to 1.0.0, see [this wiki page](https://github.com/jsdom/jsdom/wiki/Changes-from-0.11.1-to-1.0.0).
+
+* Remove: nonstandard `EventTarget.getListeners`; `EventTarget.forwardIterator`; `EventTarget.backwardIterator`; `EventTarget.singleIterator`.
+* Remove: nonstandard `document.innerHTML`. (jorendorff)
+* Fix: `value` and `defaultValue` properties of a `HTMLInputElement` are now correctly synced to the `value=""` attribute. (Sebmaster)
+
+## 1.0.0-pre.7
+
+* Remove: support for old, untested HTML and XML parsers, namely davglass/node-htmlparser and isaacs/sax-js. In the future we plan to work toward a standardized parsing interface that other parsers can implement, instead of adding custom code to jsdom for various parsers. This interface still is being decided though, as it needs to support complex things like pausing the parse stream (for `document.write`) and parsing disconnected fragments (for `document.innerHTML`). (Sebmaster)
+* Add: new `parsingMode` configuration, to allow you to manually specify XML or HTML. (Sebmaster)
+* Change: jsdom will no longer use the presence of `<?xml` or similar to attempt to auto-detect XHTML documents. Instead, it will by default treat them the same as browsers do, with the `<?xml` declaration just being a bogus comment. If you need your document interpreted as XHTML instead of HTML, use the `parsingMode` option. (Sebmaster)
+* Tweak: memoize various DOM-querying functions (e.g. `getElementsByTagName`, `querySelector`, etc.) to improve performance. (ccarpita)
+
+## 1.0.0-pre.6
+
+* Fix: another parsing issues with void elements and `innerHTML`, this time related to disconnected nodes. This was a regression between 0.11.1 and 1.0.0-pre.1. (paton)
+* Fix: same-named radio inputs should not be mutually exclusive unless they are in the same form. (stof)
+
+## 1.0.0-pre.5
+
+* Fix: sometimes calling `window.close()` would cause a segfault. (paton)
+
+## 1.0.0-pre.4
+
+* Fix: attributes and elements now have their `prefix`, `localName`, and `namespaceURI` properties set correctly in all cases. (Excepting `application/xhtml+xml` mode, which jsdom does not support yet.) (Sebmaster)
+
+## 1.0.0-pre.3
+
+* Fix: void elements no longer parsed correctly when using `innerHTML`. This was a regression between 0.11.1 and 1.0.0-pre.1. (Sebmaster)
+
+## 1.0.0-pre.2
+
+* Fix: parsing and serialization of attributes in the form `x:y`, e.g. `xmlns:xlink` or `xlink:href`. This was a regression between 0.11.1 and 1.0.0-pre.1. (Sebmaster)
+
+## 1.0.0-pre.1
+
+This is a prerelease of jsdom's first major version. It incorporates several great additions, as well as a general cleanup of the API surface, which make it more backward-incompatible than usual. Starting with the 1.0.0 release, we will be following semantic versioning, so that you can depend on stability within major version ranges. But we still have [a few more issues](https://github.com/jsdom/jsdom/issues?q=is%3Aopen+is%3Aissue+milestone%3A1.0) before we can get there, so I don't want to do 1.0.0 quite yet.
+
+This release owes a special thanks to [@Sebmaster](https://github.com/Sebmaster), for his amazing work taking on some of the hardest problems in jsdom and solving them with gusto.
+
+### Major changes
+
+* jsdom now can be browserified into a bundle that works in web workers! This is highly experimental, but also highly exciting! (lawnsea)
+* An overhaul of the [initialization lifecycle](https://github.com/jsdom/jsdom#initialization-lifecycle), to bring more control and address common use cases. (Sebmaster)
+* The excellent [parse5](https://npmjs.org/package/parse5) HTML parser is now the default parser, fixing many parsing bugs and giving us full, official-test-suite-passing HTML parsing support. This especially impacts documents that didn't include optional tags like `<html>`, `<head>`, or `<body>` in their source. We also use parse5 for serialization, fixing many bugs there. (Sebmaster)
+* As part of the new parser story, we are not supporting XML for now. It might work if you switch to a different parser (e.g. htmlparser2), but in the end, HTML and XML are very different, and we are not attempting to be an XML DOM. That said, we eventually want to support XML to the same extent browsers do (i.e., support XHTML and SVG, with an appropriate MIME type switch); this is being planned in [#820](https://github.com/jsdom/jsdom/issues/820).
+
+### Removed jsdom APIs
+
+* `jsdom.createWindow`: use `document.parentWindow` after creating a document
+* `jsdom.html`: use `jsdom.jsdom`
+* `jsdom.version`: use `require("jsdom/package.json").version`
+* `jsdom.level`: levels are deprecated and will probably be removed in 2.0.0
+* `jsdom.dom`
+* `jsdom.browserAugmentation`
+* `jsdom.windowAugmentation`
+
+### Changed jsdom APIs
+
+* `jsdom.jsdom` no longer takes a level as its second argument.
+* `jsdom.jQueryify` now requires a jQuery URL, since [always picking the latest was a bad idea](http://blog.jquery.com/2014/07/03/dont-use-jquery-latest-js/).
+
+### Removed non-standard DOM APIs
+
+* `document.createWindow`: use `document.parentWindow`
+* `document.innerHTML` and `document.outerHTML`: use the new `jsdom.serializeDocument` to include the DOCTYPE, or use `document.documentElement.outerHTML` to omit it.
+
+### Other fixes
+
+* Allow empty strings to be passed to `jsdom.env`. (michaelmior)
+* Fix for a memory leak in `EventTarget.prototype.dispatchEvent`. (Joris-van-der-Wel)
+* Make event listeners in the capture phase also fire on the event target. (Joris-van-der-Wel)
+* Correctly reset `eventPhase` and `currentTarget` on events, before and after a dispatch. (Joris-van-der-Wel)
+* Fix `document.cookie = null` to not throw, but instead just do nothing. (kapouer)
+
+## 0.11.1
+
+* Add: `Node.prototype.parentElement`. (lukasbuenger)
+* Fix: attributes that are reflected as properties should be `''` when not present, instead of `null`. (Note that `getAttribute` still returns `null` for them). (thejameskyle)
+* Fix: `textContent` now works for nodes that do not have children, like text nodes for example. (hayes)
+* Fix: `jsdom.jQueryify` was using the wrong URL for jQuery by default. (lukasbuenger)
+
+## 0.11.0
+
+* Add: new default level, `living`, reflecting our focus on the [DOM Living Standard](http://dom.spec.whatwg.org/) and the [HTML Living Standard](http://www.whatwg.org/specs/web-apps/current-work/multipage/), which are what browsers actually implement. This should open the door for more features of the modern DOM and HTML specs to be implemented in jsdom. (robotlovesyou)
+* Add: `Node.prototype.contains` now implemented. (robotlovesyou)
+* Add: `navigator.cookieEnabled` now implemented; it always returns `true`. (Sebmaster)
+* Change: DOCTYPEs no longer have their `name` property uppercased during parsing, and appear in the output of `document.innerHTML`.
+* Fix: `Node.prototype.compareDocumentPosition` implemented correctly; various document position constants added to the `Node` constructor. (robotlovesyou)
+* Fix: `DocumentType.prototype.parentNode` now returns the document node, not `null`. (robotlovesyou)
+* Fix: various `navigator` properties are now getters, not data properties. (Sebmaster)
+* Fix: a bug involving invalid script paths and `jsdom.jQueryify`. (Sebmaster)
+
+## 0.10.6
+
+* Add: remaining URL properties to `window.location` and `HTMLAnchorElement`.
+* Fix: the presence of `String.prototype.normalize`, which is available by default in Node 0.11.13 onwards, caused reflected attributes to break. (brock8503)
+* Fix: iframes now correctly load `about:blank` when the `src` attribute is empty or missing. (mcmathja)
+* Fix: documents containing only whitespace now correctly generate wrapper documents, just like blank documents do. (nikolas)
+* Tweak: lazy-load the request module, to improve overall jsdom loading time. (tantaman)
+
+## 0.10.5
+
+* Fix: the list of void elements has been updated to match the latest HTML spec.
+* Fix: when serializing void elements, don't include a ` /`: i.e. the result is now `<br>` instead of `<br />`.
+
+## 0.10.4
+
+* Fix: another case was found where jQuery 1.11's `show()` method would cause errors.
+* Add: `querySelector` and `querySelectorAll` methods to `DocumentFragment`s. (Joris-van-der-Wel)
+
+## 0.10.3
+
+* Fix: various defaults on `HTMLAnchorElement` and `window.location` should not be `null`; they should usually be the empty string.
+
+## 0.10.2
+
+* Fix: Using jQuery 1.11's `show()` method would cause an error to be thrown.
+* Fix: `window.location` properties were not updating correctly after using `pushState` or `replaceState`. (toomanydaves)
+
+## 0.10.1
+
+* Fix: `window.location.port` should default to `""`, not `null`. (bpeacock)
+
+## 0.10.0
+
+* Add: a more complete `document.cookie` implementation, that supports multiple cookies. Note that options like `path`, `max-age`, etc. are still ignored. (dai-shi)
+
+## 0.9.0
+
+* Add: implement attribute ordering semantics from WHATWG DOM spec, and in general overhaul attribute storage implementation to be much more awesome and accurate. (lddubeau)
+* Add: `port` and `protocol` to `HTMLAnchorElement`. (sporchia)
+* Fix: make `HTMLInputElement` not have a `type` *attribute* by default. It still has a default value for the `type` *property*, viz. `"text"`. (aredridel)
+* Fix: treat empty namespace URI as meaning "no namespace" with the `getAttributeNS`, `hasAttributeNS`, and `setAttributeNS` functions. (lddubeau)
+* Fix: reference typed arrays in a way that doesn't immediately break on Node 0.6. Node 0.6 isn't supported in general, though. (kangax)
+
+## 0.8.11
+
+* Add: store and use cookies between requests; customizable cookie jars also possible. (stockholmux)
+* Fix: attributes named the same as prototype properties of `NamedNodeMap` no longer break jsdom. (papandreou)
+* Fix: `removeAttributeNS` should not throw on missing attributes. (lddubeau)
+* Change: remove `__proto__`, `__defineGetter__`, and `__defineSetter__` usage, as part of a project to make jsdom work better across multiple environments. (lawnsea)
+
+## 0.8.10
+
+* Add: `hash` property to `HTMLAnchorElement`. (fr0z3nk0)
+
+## 0.8.9
+
+* Upgrade: `cssom` to 0.3.0, adding support for `@-moz-document` and fixing a few other issues.
+* Upgrade: `cssstyle` to 0.2.6, adding support for many shorthand properties and better unit handling.
+
+## 0.8.8
+
+* Fix: avoid repeated `NodeList.prototype.length` calculation, for a speed improvement. (peller)
+
+## 0.8.7
+
+* Add: `host` property to `HTMLAnchorElement`. (sporchia)
+
+## 0.8.6
+
+* Fix: stop accidentally modifying `Error.prototype`. (mitar)
+* Add: a dummy `getBoundingClientRect` method, that returns `0` for all properties of the rectangle, is now implemented. (F1LT3R)
+
+## 0.8.5
+
+* Add: `href` property on `CSSStyleSheet` instances for external CSS files. (FrozenCow)
+
+## 0.8.4
+
+ * Add: typed array constructors on the `window`. (nlacasse)
+ * Fix: `querySelector` and `querySelectorAll` should be on the prototypes of `Element` and `Document`, not own-properties. (mbostock)
+
+## 0.8.3
+
+ * Fix: when auto-detecting whether the first parameter to `jsdom.env` is a HTML string or a filename, deal with long strings correctly instead of erroring. (baryshev)
+
+## 0.8.2
+
+ * Add: basic `window.history` support, including `back`, `forward`, `go`, `pushState`, and `replaceState`. (ralphholzmann)
+ * Add: if an `<?xml?>` declaration starts the document, will try to parse as XML, e.g. not lowercasing the tags. (robdodson)
+ * Fix: tag names passed to `createElement` are coerced to strings before evaluating.
+
+## 0.8.1 (hotfix)
+
+ * Fix: a casing issue that prevented jsdom from loading on Unix and Solaris systems. (dai-shi)
+ * Fix: `window.location.replace` was broken. (dai-shi)
+ * Fix: update minimum htmlparser2 version, to ensure you get the latest parsing-related bugfixes.
+
+## 0.8.0
+
+ * Add: working `XMLHttpRequest` support, including cookie passing! (dai-shi)
+ * Add: there is now a `window.navigator.noUI` property that evaluates to true, if you want to specifically distinguish jsdom in your tests.
+
+## 0.7.0
+
+ * Change: the logic when passing `jsdom.env` a string is more accurate, and you can be explicit by using the `html`, `url`, or `file` properties. This is a breaking change in the behavior of `html`, which used to do the same auto-detection logic as the string-only version.
+ * Fix: errors raised in scripts are now passed to `jsdom.env`'s callback. (airportyh)
+ * Fix: set `window.location.href` correctly when using `jsdom.env` to construct a window from a URL, when that URL causes a redirect. (fegs)
+ * Add: a more complete and accurate `window.location` object, which includes firing `hashchange` events when the hash is changed. (dai-shi)
+ * Add: when using a non-implemented feature, mention exactly what it was that is not implemented in the error message. (papandreou)
+
+## 0.6.5
+
+ * Fix: custom attributes whose names were the same as properties of `Object.prototype`, e.g. `"constructor"`, would confuse jsdom massively.
+
+## 0.6.4
+
+ * Fix: CSS selectors which contain commas inside quotes are no longer misinterpreted. (chad3814)
+ * Add: `<img>` elements now fire `load` events when their `src` attributes are changed. (kapouer)
+
+## 0.6.3
+
+ * Fix: better automatic detection of URLs vs. HTML fragments when using `jsdom.env`. (jden)
+
+## 0.6.2
+
+ * Fix: URL resolution to be amazing and extremely browser-compatible, including the interplay between the document's original URL, any `<base>` tags that were set, and any relative `href`s. This impacts many parts of jsdom having to do with external resources or accurate `href` and `src` attributes. (deitch)
+ * Add: access to frames and iframes via named properties. (adrianlang)
+ * Fix: node-canvas integration, which had been broken since 0.5.7.
+
+## 0.6.1
+
+ * Make the code parseable with Esprima. (squarooticus)
+ * Use the correct `package.json` field `"repository"` instead of `"repositories"` to prevent npm warnings. (jonathanong)
+
+## 0.6.0
+
+Integrated a new HTML parser, [htmlparser2](https://npmjs.org/package/htmlparser2), from fb55. This is an actively maintained and much less buggy parser, fixing many of our parsing issues, including:
+
+ * Parsing elements with optional closing tags, like `<p>` or `<td>`.
+ * The `innerHTML` of `<script>` tags no longer cuts off the first character.
+ * Empty attributes now have `""` as their value instead of the attribute name.
+ * Multiline attributes no longer get horribly mangled.
+ * Attribute names can now be any value allowed by HTML5, including crazy things like `^`.
+ * Attribute values can now contain any value allowed by HTML5, including e.g. `>` and `<`.
+
+## 0.5.7
+
+ * Fix: make event handlers attached via `on<event>` more spec-compatible, supporting `return false` and passing the `event` argument. (adrianlang)
+ * Fix: make the getter for `textContent` more accurate, e.g. in cases involving comment nodes or processing instruction nodes. (adrianlang)
+ * Fix: make `<canvas>` behave like a `<div>` when the `node-canvas` package isn't available, instead of crashing. (stepheneb)
+
+## 0.5.6
+
+ * Fix: `on<event>` properties are correctly updated when using `setAttributeNode`, `attributeNode.value =`, `removeAttribute`, and `removeAttributeNode`; before it only worked with `setAttribute`. (adrianlang)
+ * Fix: `HTMLCollection`s now have named properties based on their members' `id` and `name` attributes, e.g. `form.elements.inputId` is now present. (adrianlang)
+
+## 0.5.5
+
+ * Fix: `readOnly` and `selected` properties were not correct when their attribute values were falsy, e.g. `<option selected="">`. (adrianlang)
+
+## 0.5.4
+
+This release, and all future releases, require at least Node.js 0.8.
+
+ * Add: parser can now be set via `jsdom.env` configuration. (xavi-)
+ * Fix: accessing `rowIndex` for table rows that are not part of a table would throw. (medikoo)
+ * Fix: several places in the code accidentally created global variables, or referenced nonexistant values. (xavi-)
+ * Fix: `<img>` elements' `src` properties now evaluate relative to `location.href`, just like `<a>` elements' `href` properties. (brianmaissy)
+
+## 0.5.3
+
+This release is compatible with Node.js 0.6, whereas all future releases will require at least Node.js 0.8.
+
+ * Fix: `getAttributeNS` now returns `null` for attributes that are not present, just like `getAttribute`. (mbostock)
+ * Change: `"request"` dependency pinned to version 2.14 for Node.js 0.6 compatibility.
+
+## 0.5.2
+
+ * Fix: stylesheets with `@-webkit-keyframes` rules were crashing calls to `getComputedStyle`.
+ * Fix: handling of `features` option to `jsdom.env`.
+ * Change: retain the value of the `style` attribute until the element's `style` property is touched. (papandreou)
+
+## 0.5.1
+
+ * Fix: `selectedIndex` now changes correctly in response to `<option>` elements being selected. This makes `<select>` elements actually work like you would want, especially with jQuery. (xcoderzach)
+ * Fix: `checked` works correctly on radio buttons, i.e. only one can be checked and clicking on one does not uncheck it. Previously they worked just like checkboxes. (xcoderzach)
+ * Fix: `click()` on `<input>` elements now fires a click event. (xcoderzach)
+
+## 0.5.0
+
+ * Fix: Make `contextify` a non-optional dependency. jsdom never worked without it, really, so this just caused confusion.
+
+## 0.4.2
+
+ * Fix: `selected` now returns true for the first `<option>` in a `<select>` if nothing is explicitly set.
+ * Fix: tweaks to accuracy and speed of the `querySelectorAll` implementation.
+
+## 0.4.1 (hotfix)
+
+ * Fix: crashes when loading HTML files with `<a>` tags with no `href` attribute. (eleith)
+
+## 0.4.0
+
+ * Fix: `getAttribute` now returns `null` for attributes that are not present, as per DOM4 (but in contradiction to DOM1 through DOM3).
+ * Fix: static `NodeList`-returning methods (such as `querySelectorAll`) now return a real `NodeList` instance.
+ * Change: `NodeList`s no longer expose nonstandard properties to the world, like `toArray`, without first prefixing them with an underscore.
+ * Change: `NodeList`s no longer inconsistently have array methods. Previously, live node lists would have `indexOf`, while static node lists would have them all. Now, they have no array methods at all, as is correct per the specification.
+
+## 0.3.4
+
+ * Fix: stylesheets with `@media` rules were crashing calls to `getComputedStyle`, e.g. those in jQuery's initialization.
+
+## 0.3.3
+
+ * Fix: make `document.write` calls insert new elements correctly. (johanoverip, kblomquist).
+ * Fix: `<input>` tags with no `type` attribute now return a default value of `"text"` when calling `inputEl.getAttribute("type")`.
+
+## 0.3.2
+
+ * Fix: stylesheets with "joining" rules (i.e. those containing comma-separated selectors) now apply when using `getComputedStyle`. (chad3814, godmar)
+ * Add: support for running the tests using @aredridel's [html5](https://npmjs.org/package/html5) parser, as a prelude toward maybe eventually making this the default and fixing various parsing bugs.
+
+## 0.3.1 (hotfix)
+
+ * Fix: crashes when invalid selectors were present in stylesheets.
+
+## 0.3.0
+
+ * Fix: a real `querySelector` implementation, courtesy of the nwmatcher project, solves many outstanding `querySelector` bugs.
+ * Add: `matchesSelector`, again via nwmatcher.
+ * Add: support for styles coming from `<style>` and `<link rel="stylesheet">` elements being applied to the results of `window.getComputedStyle`. (chad3814)
+ * Add: basic implementation of `focus()` and `blur()` methods on appropriate elements. More work remains.
+ * Fix: script filenames containing spaces will now work when passed to `jsdom.env`. (TomNomNom)
+ * Fix: elements with IDs `toString`, `hasOwnProperty`, etc. could cause lots of problems.
+ * Change: A window's `load` event always fires asynchronously now, even if no external resources are necessary.
+ * Change: turning off mutation events is not supported, since doing so breaks external-resource fetching.
+
+## 0.2.19
+
+ * Fix: URL resolution was broken on pages that included `href`-less `<base>` tags.
+ * Fix: avoid putting `attr` in the global scope when using node-canvas. (starsquare)
+ * Add: New `SkipExternalResources` feature accepts a regular expression. (fgalassi)
+
+## 0.2.18
+
+ * Un-revert: cssstyle has fixed its memory problems, so we get back accurate `cssText` and `style` properties again.
+
+## 0.2.17 (hotfix)
+
+ * Revert: had to revert the use of the cssstyle package. `cssText` and `style` properties are no longer as accurate.
+ * Fix: cssstyle was causing out-of-memory errors on some larger real-world pages, e.g. reddit.com.
+
+## 0.2.16
+ * Update: Sizzle version updated to circa September 2012.
+ * Fix: when setting a text node's value to a falsy value, convert it to a string instead of coercing it to `""`.
+ * Fix: Use the cssstyle package for `CSSStyleDeclaration`, giving much more accurate `cssText` and `style` properties on all elements. (chad3814)
+ * Fix: the `checked` property on checkboxes and radiobuttons now reflects the attribute correctly.
+ * Fix: `HTMLOptionElement`'s `text` property should return the option's text, not its value.
+ * Fix: make the `name` property only exist on certain specific tags, and accurately reflect the corresponding `name` attribute.
+ * Fix: don't format `outerHTML` (especially important for `<pre>` elements).
+ * Fix: remove the `value` property from `Text` instances (e.g. text nodes).
+ * Fix: don't break in the presence of a `String.prototype.normalize` method, like that of sugar.js.
+ * Fix: include level3/xpath correctly.
+ * Fix: many more tests passing, especially related to file:/// URLs on Windows. Tests can now be run with `npm test`.
+
+## 0.2.15
+ * Fix: make sure that doctypes don't get set as the documentElement (Aria Stewart)
+ * Add: HTTP proxy support for jsdom.env (Eugene Ware)
+ * Add: .hostname and .pathname properties to Anchor elements to comply with WHATWG standard (Avi Deitcher)
+ * Fix: Only decode HTML entities in text when not inside a `<script>` or `<style>` tag. (Andreas Lind Petersen)
+ * Fix: HTMLSelectElement single selection implemented its type incorrectly as 'select' instead of 'select-one' (John Roberts)
+
+## 0.2.14
+ * Fix: when serializing single tags use ' />' instead of '/>' (kapouer)
+ * Fix: support for contextify simulation using vm.runInContext (trodrigues)
+ * Fix: allow jsdom.env's config.html to handle file paths which contain spaces (shinuza)
+ * Fix: Isolate QuerySelector from prototype (Nao Iizuka)
+ * Add: setting textContent to '' or clears children (Jason Davies)
+ * Fix: jsdom.env swallows exceptions that occur in the callback (Xavi)
+
+## 0.2.13
+ * Fix: remove unused style property which was causing explosions in 0.2.12 and node 0.4.7
+
+## 0.2.12
+ * Fix: do not include gmon.out/v8.log/tests in npm distribution
+
+## 0.2.11
+ * Add: allow non-unique element ids (Avi Deitcher)
+ * Fix: make contexify an optional dependency (Isaac Schlueter)
+ * Add: scripts injected by jsdom are now marked with a 'jsdom' class for serialization's sake (Peter Lyons)
+ * Fix: definition for ldquo entity (Andrew Morton)
+ * Fix: access NamedNodeMap items via property (Brian McDaniel)
+ * Add: upgrade sizzle from 1.0 to [fe2f6181](https://github.com/jquery/sizzle/commit/fe2f618106bb76857b229113d6d11653707d0b22) which is roughly 1.5.1
+ * Add: documentation now includes `jsdom.level(x, 'feature')`
+ * Fix: make `toArray` and `item` on `NodeList` objects non-enumerable properties
+ * Add: a reference to `window.close` in the readme
+ * Fix: Major performance boost (Felix Gnass)
+ * Fix: Using querySelector `:not()` throws a `ReferenceError` (Felix Gnass)
+
+## 0.2.10
+ * Fix: problems with lax dependency versions
+ * Fix: CSSOM constructors are hung off of the dom (Brian McDaniel)
+ * Fix: move away from deprecated 'sys' module
+ * Fix: attribute event handlers on bubbling path aren't called (Brian McDaniel)
+ * Fix: setting textarea.value to markup should not be parsed (Andreas Lind Petersen)
+ * Fix: content of script tags should not be escaped (Ken Sternberg)
+ * Fix: DocumentFeatures for iframes with no src attribute. (Brian McDaniel) Closes #355
+ * Fix: 'trigger' to 'raise' to be a bit more descriptive
+ * Fix: When `ProcessExternalResources['script']` is disabled, do _not_ run inline event handlers. #355
+ * Add: verbose flag to test runner (to show tests as they are running and finishing)
+
+## 0.2.9
+ * Fix: ensure features are properly reset after a jsdom.env invocation. Closes #239
+ * Fix: ReferenceError in the scanForImportRules helper function
+ * Fix: bug in appendHtmlToElement with HTML5 parser (Brian McDaniel)
+ * Add: jsonp support (lheiskan)
+ * Fix: for setting script element's text property (Brian McDaniel)
+ * Fix: for jsdom.env src bug
+ * Add: test for jsdom.env src bug (multiple done calls)
+ * Fix: NodeList properties should enumerate like arrays (Felix Gnass)
+ * Fix: when downloading a file, include the url.search in file path
+ * Add: test for making a jsonp request with jquery from jsdom window
+ * Add: test case for issue #338
+ * Fix: double load behavior when mixing jsdom.env's `scripts` and `src` properties (cjroebuck)
+
+## 0.2.8 (hotfix)
+ * Fix: inline event handlers are ignored by everything except for the javascript context
+
+## 0.2.7 (hotfix)
+ * Fix stylesheet loading
+
+## 0.2.6
+ * Add: support for window.location.search and document.cookie (Derek Lindahl)
+ * Add: jsdom.env now has a document configuation option which allows users to change the referer of the document (Derek Lindahl)
+ * Fix: allow users to use different jsdom levels in the same process (sinegar)
+ * Fix: removeAttributeNS no longer has a return value (Jason Davies)
+ * Add: support for encoding/decoding all html entities from html4/5 (papandreou)
+ * Add: jsdom.env() accepts the same features object seen in jsdom.jsdom and friends
+
+## 0.2.5
+ * Fix: serialize special characters in Element.innerHTML/Element.attributes like a grade A browser (Jason Priestley)
+ * Fix: ensure Element.getElementById only returns elements that are attached to the document
+ * Fix: ensure an Element's id is updated when changing the nodeValue of the 'id' attribute (Felix Gnass)
+ * Add: stacktrace to error reporter (Josh Marshall)
+ * Fix: events now bubble up to the window (Jason Davies)
+ * Add: initial window.location.hash support (Josh Marshall)
+ * Add: Node#insertBefore should do nothing when both params are the same node (Jason Davies)
+ * Add: fixes for DOMAttrModified mutation events (Felix Gnass)
+
+## 0.2.4
+ * Fix: adding script to invalid/incomplete dom (document.documentElement) now catches the error and passes it in the `.env` callback (Gregory Tomlinson)
+ * Cleanup: trigger and html tests
+ * Add: support for inline event handlers (ie: `<div onclick='some.horrible.string()'>`) (Brian McDaniel)
+ * Fix: script loading over https (Brian McDaniel) #280
+ * Add: using style.setProperty updates the style attribute (Jimmy Mabey).
+ * Add: invalid markup is reported as an error and attached to the associated element and document
+ * Fix: crash when setChild() failes to create new DOM element (John Hurliman)
+ * Added test for issue #287.
+ * Added support for inline event handlers.
+ * Moved frame tests to test/window/frame.js and cleaned up formatting.
+ * Moved script execution tests to test/window/script.js.
+ * Fix a crash when setChild() fails to create a new DOM element
+ * Override CSSOM to update style attribute
+
+## 0.2.3
+ * Fix: segfault due to window being garbage collected prematurely
+    NOTE: you must manually close the window to free memory (window.close())
+
+## 0.2.2
+ * Switch to Contextify to manage the window's script execution.
+ * Fix: allow nodelists to have a length of 0 and toArray to return an empty array
+ * Fix: style serialization; issues #230 and #259
+ * Fix: Incomplete DOCTYPE causes JavaScript error
+ * Fix: indentation, removed outdated debug code and trailing whitespace.
+ * Prevent JavaScript error when parsing incomplete `<!DOCTYPE>`. Closes #259.
+ * Adding a test from brianmcd that ensures that setTimeout callbacks execute in the context of the window
+ * Fixes issue 250: make `document.parentWindow === window` work
+ * Added test to ensure that timer callbacks execute in the window context.
+ * Fixes 2 issues in ResourceQueue
+ * Make frame/iframe load/process scripts if the parent has the features enabled
+
+## 0.2.1
+ * Javascript execution fixes [#248, #163, #179]
+ * XPath (Yonathan and Daniel Cassidy)
+ * Start of cssom integration (Yonathan)
+ * Conversion of tests to nodeunit! (Martin Davis)
+ * Added sizzle tests, only failing 3/15
+ * Set the title node's textContent rather than its innerHTML #242.  (Andreas Lind Petersen)
+ * The textContent getter now walks the DOM and extract the text properly. (Andreas Lind Petersen)
+ * Empty scripts won't cause jsdom.env to hang #172 (Karuna Sagar)
+ * Every document has either a body or a frameset #82. (Karuna Sagar)
+ * Added the ability to grab a level by string + feature. ie: jsdom.level(2, 'html') (Aria Stewart)
+ * Cleaned up htmlencoding and fixed character (de)entification #147, #177 (Andreas Lind Petersen)
+ * htmlencoding.HTMLDecode: Fixed decoding of `&lt;`, `&gt;`, `&amp;`, and `&apos;`. Closes #147 and #177.
+ * Require dom level as a string or object. (Aria Stewart)
+ * JS errors ar triggered on the script element, not document. (Yonathan)
+ * Added configuration property 'headers' for HTTP request headers. (antonj)
+ * Attr.specified is readonly - Karuna Sagar
+ * Removed return value from setAttributeNS() #207 (Karuna Sagar)
+ * Pass the correct script filename to runInContext. (robin)
+ * Add http referrer support for the download() function. (Robin)
+ * First attempt at fixing the horrible memory leak via window.stopTimers() (d-ash)
+ * Use vm instead of evals binding (d-ash)
+ * Add a way to set the encoding of the jsdom.env html request.
+ * Fixed various typos/lint problems (d-ash)
+ * The first parameter download is now the object returned by URL.parse(). (Robin)
+ * Fixed serialization of elements with a style attribute.
+ * Added src config option to jsdom.env() (Jerry Sievert)
+ * Removed dead code from getNamedItemNS() (Karuna Sagar)
+ * Changes to language/javascript so jsdom would work on v0.5.0-pre (Gord Tanner)
+ * Correct spelling of "Hierarchy request error" (Daniel Cassidy)
+ * Node and Exception type constants are available in all levels. (Daniel Cassidy)
+ * Use \n instead of \r\n during serialization
+ * Fixed auto-insertion of body/html tags  (Adrian Makowski)
+ * Adopt unowned nodes when added to the tree. (Aria Stewart)
+ * Fix the selected and defaultSelected fields of `option` element. - Yonathan
+ * Fix: EventTarget.getListeners() now returns a shallow copy so that listeners can be safely removed while an event is being dispatched. (Felix Gnass)
+ * Added removeEventListener() to DOMWindow (Felix Gnass)
+ * Added the ability to pre-load scripts for jsdom.env() (Jerry Sievert)
+ * Mutation event tests/fixes (Felix Gnass)
+ * Changed HTML serialization code to (optionally) pretty print while traversing the tree instead of doing a regexp-based postprocessing. (Andreas Lind Petersen)
+ * Relative and absolute urls now work as expected
+ * setNamedItem no longer sets Node.parentNode #153 (Karuna Sagar)
+ * Added missing semicolon after entity name - Felix Gnass
+ * Added NodeList#indexOf implementation/tests (Karuna Sagar)
+ * resourceLoader.download now works correctly with https and redirects (waslogic)
+ * Scheme-less URLs default to the current protocol #87 (Alexander Flatter)
+ * Simplification the prevSibling(), appendChild(), insertBefore() and replaceChild() code (Karuna Sagar)
+ * Javascript errors use core.Node.trigger (Alexander Flatter)
+ * Add core.Document.trigger in level1/core and level2/events; Make DOMWindow.console use it (Alexander Flatter)
+ * Resource resolver fixes (Alexander Flatter)
+ * Fix serialization of doctypes with new lines #148 (Karuna Sagar)
+ * Child nodes are calculated immediately instead of after .length is called #169, #171, #176 (Karuna Sagar)
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..0dbd429
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,22 @@
+Copyright (c) 2010 Elijah Insua
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..dc4f270
--- /dev/null
+++ b/README.md
@@ -0,0 +1,520 @@
+<h1 align="center">
+    <img width="100" height="100" src="logo.svg" alt=""><br>
+    jsdom
+</h1>
+
+jsdom is a pure-JavaScript implementation of many web standards, notably the WHATWG [DOM](https://dom.spec.whatwg.org/) and [HTML](https://html.spec.whatwg.org/multipage/) Standards, for use with Node.js. In general, the goal of the project is to emulate enough of a subset of a web browser to be useful for testing and scraping real-world web applications.
+
+The latest versions of jsdom require Node.js v10 or newer. (Versions of jsdom below v16 still work with previous Node.js versions, but are unsupported.)
+
+## Basic usage
+
+```js
+const jsdom = require("jsdom");
+const { JSDOM } = jsdom;
+```
+
+To use jsdom, you will primarily use the `JSDOM` constructor, which is a named export of the jsdom main module. Pass the constructor a string. You will get back a `JSDOM` object, which has a number of useful properties, notably `window`:
+
+```js
+const dom = new JSDOM(`<!DOCTYPE html><p>Hello world</p>`);
+console.log(dom.window.document.querySelector("p").textContent); // "Hello world"
+```
+
+(Note that jsdom will parse the HTML you pass it just like a browser does, including implied `<html>`, `<head>`, and `<body>` tags.)
+
+The resulting object is an instance of the `JSDOM` class, which contains a number of useful properties and methods besides `window`. In general, it can be used to act on the jsdom from the "outside," doing things that are not possible with the normal DOM APIs. For simple cases, where you don't need any of this functionality, we recommend a coding pattern like
+
+```js
+const { window } = new JSDOM(`...`);
+// or even
+const { document } = (new JSDOM(`...`)).window;
+```
+
+Full documentation on everything you can do with the `JSDOM` class is below, in the section "`JSDOM` Object API".
+
+## Customizing jsdom
+
+The `JSDOM` constructor accepts a second parameter which can be used to customize your jsdom in the following ways.
+
+### Simple options
+
+```js
+const dom = new JSDOM(``, {
+  url: "https://example.org/",
+  referrer: "https://example.com/",
+  contentType: "text/html",
+  includeNodeLocations: true,
+  storageQuota: 10000000
+});
+```
+
+- `url` sets the value returned by `window.location`, `document.URL`, and `document.documentURI`, and affects things like resolution of relative URLs within the document and the same-origin restrictions and referrer used while fetching subresources. It defaults to `"about:blank"`.
+- `referrer` just affects the value read from `document.referrer`. It defaults to no referrer (which reflects as the empty string).
+- `contentType` affects the value read from `document.contentType`, as well as how the document is parsed: as HTML or as XML. Values that are not a [HTML mime type](https://mimesniff.spec.whatwg.org/#html-mime-type) or an [XML mime type](https://mimesniff.spec.whatwg.org/#xml-mime-type) will throw. It defaults to `"text/html"`. If a `charset` parameter is present, it can affect [binary data processing](#encoding-sniffing).
+- `includeNodeLocations` preserves the location info produced by the HTML parser, allowing you to retrieve it with the `nodeLocation()` method (described below). It also ensures that line numbers reported in exception stack traces for code running inside `<script>` elements are correct. It defaults to `false` to give the best performance, and cannot be used with an XML content type since our XML parser does not support location info.
+- `storageQuota` is the maximum size in code units for the separate storage areas used by `localStorage` and `sessionStorage`. Attempts to store data larger than this limit will cause a `DOMException` to be thrown. By default, it is set to 5,000,000 code units per origin, as inspired by the HTML specification.
+
+Note that both `url` and `referrer` are canonicalized before they're used, so e.g. if you pass in `"https:example.com"`, jsdom will interpret that as if you had given `"https://example.com/"`. If you pass an unparseable URL, the call will throw. (URLs are parsed and serialized according to the [URL Standard](http://url.spec.whatwg.org/).)
+
+### Executing scripts
+
+jsdom's most powerful ability is that it can execute scripts inside the jsdom. These scripts can modify the content of the page and access all the web platform APIs jsdom implements.
+
+However, this is also highly dangerous when dealing with untrusted content. The jsdom sandbox is not foolproof, and code running inside the DOM's `<script>`s can, if it tries hard enough, get access to the Node.js environment, and thus to your machine. As such, the ability to execute scripts embedded in the HTML is disabled by default:
+
+```js
+const dom = new JSDOM(`<body>
+  <script>document.body.appendChild(document.createElement("hr"));</script>
+</body>`);
+
+// The script will not be executed, by default:
+dom.window.document.body.children.length === 1;
+```
+
+To enable executing scripts inside the page, you can use the `runScripts: "dangerously"` option:
+
+```js
+const dom = new JSDOM(`<body>
+  <script>document.body.appendChild(document.createElement("hr"));</script>
+</body>`, { runScripts: "dangerously" });
+
+// The script will be executed and modify the DOM:
+dom.window.document.body.children.length === 2;
+```
+
+Again we emphasize to only use this when feeding jsdom code you know is safe. If you use it on arbitrary user-supplied code, or code from the Internet, you are effectively running untrusted Node.js code, and your machine could be compromised.
+
+If you want to execute _external_ scripts, included via `<script src="">`, you'll also need to ensure that they load them. To do this, add the option `resources: "usable"` [as described below](#loading-subresources).
+
+Event handler attributes, like `<div onclick="">`, are also governed by this setting; they will not function unless `runScripts` is set to `"dangerously"`. (However, event handler _properties_, like `div.onclick = ...`, will function regardless of `runScripts`.)
+
+If you are simply trying to execute script "from the outside", instead of letting `<script>` elements and event handlers attributes run "from the inside", you can use the `runScripts: "outside-only"` option, which enables fresh copies of all the JavaScript spec-provided globals to be installed on `window`. This includes things like `window.Array`, `window.Promise`, etc. It also, notably, includes `window.eval`, which allows running scripts, but with the jsdom `window` as the global:
+
+```js
+const { window } = new JSDOM(``, { runScripts: "outside-only" });
+
+window.eval(`document.body.innerHTML = "<p>Hello, world!</p>";`);
+window.document.body.children.length === 1;
+```
+
+This is turned off by default for performance reasons, but is safe to enable.
+
+(Note that in the default configuration, without setting `runScripts`, the values of `window.Array`, `window.eval`, etc. will be the same as those provided by the outer Node.js environment. That is, `window.eval === eval` will hold, so `window.eval` will not run scripts in a useful way.)
+
+We strongly advise against trying to "execute scripts" by mashing together the jsdom and Node global environments (e.g. by doing `global.window = dom.window`), and then executing scripts or test code inside the Node global environment. Instead, you should treat jsdom like you would a browser, and run all scripts and tests that need access to a DOM inside the jsdom environment, using `window.eval` or `runScripts: "dangerously"`. This might require, for example, creating a browserify bundle to execute as a `<script>` element—just like you would in a browser.
+
+Finally, for advanced use cases you can use the `dom.getInternalVMContext()` method, documented below.
+
+### Pretending to be a visual browser
+
+jsdom does not have the capability to render visual content, and will act like a headless browser by default. It provides hints to web pages through APIs such as `document.hidden` that their content is not visible.
+
+When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying content. It does this by:
+
+* Changing `document.hidden` to return `false` instead of `true`
+* Changing `document.visibilityState` to return `"visible"` instead of `"prerender"`
+* Enabling `window.requestAnimationFrame()` and `window.cancelAnimationFrame()` methods, which otherwise do not exist
+
+```js
+const window = (new JSDOM(``, { pretendToBeVisual: true })).window;
+
+window.requestAnimationFrame(timestamp => {
+  console.log(timestamp > 0);
+});
+```
+
+Note that jsdom still [does not do any layout or rendering](#unimplemented-parts-of-the-web-platform), so this is really just about _pretending_ to be visual, not about implementing the parts of the platform a real, visual web browser would implement.
+
+### Loading subresources
+
+#### Basic options
+
+By default, jsdom will not load any subresources such as scripts, stylesheets, images, or iframes. If you'd like jsdom to load such resources, you can pass the `resources: "usable"` option, which will load all usable resources. Those are:
+
+* Frames and iframes, via `<frame>` and `<iframe>`
+* Stylesheets, via `<link rel="stylesheet">`
+* Scripts, via `<script>`, but only if `runScripts: "dangerously"` is also set
+* Images, via `<img>`, but only if the `canvas` npm package is also installed (see "[Canvas Support](#canvas-support)" below)
+
+#### Advanced configuration
+
+_This resource loader system is new as of jsdom v12.0.0, and we'd love your feedback on whether it meets your needs and how easy it is to use. Please file an issue to discuss!_
+
+To more fully customize jsdom's resource-loading behavior, you can pass an instance of the `ResourceLoader` class as the `resources` option value:
+
+```js
+const resourceLoader = new jsdom.ResourceLoader({
+  proxy: "http://127.0.0.1:9001",
+  strictSSL: false,
+  userAgent: "Mellblomenator/9000",
+});
+const dom = new JSDOM(``, { resources: resourceLoader });
+```
+
+The three options to the `ResourceLoader` constructor are:
+
+- `proxy` is the address of an HTTP proxy to be used.
+- `strictSSL` can be set to false to disable the requirement that SSL certificates be valid.
+- `userAgent` affects the `User-Agent` header sent, and thus the resulting value for `navigator.userAgent`. It defaults to <code>\`Mozilla/5.0 (${process.platform || "unknown OS"}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}\`</code>.
+
+You can further customize resource fetching by subclassing `ResourceLoader` and overriding the `fetch()` method. For example, here is a version that only returns results for requests to a trusted origin:
+
+```js
+class CustomResourceLoader extends jsdom.ResourceLoader {
+  fetch(url, options) {
+    // Override the contents of this script to do something unusual.
+    if (url === "https://example.com/some-specific-script.js") {
+      return Promise.resolve(Buffer.from("window.someGlobal = 5;"));
+    }
+
+    return super.fetch(url, options);
+  }
+}
+```
+
+jsdom will call your custom resource loader's `fetch()` method whenever it encounters a "usable" resource, per the above section. The method takes a URL string, as well as a few options which you should pass through unmodified if calling `super.fetch()`. It must return a promise for a Node.js `Buffer` object, or return `null` if the resource is intentionally not to be loaded. In general, most cases will want to delegate to `super.fetch()`, as shown.
+
+One of the options you will receive in `fetch()` will be the element (if applicable) that is fetching a resource.
+
+```js
+class CustomResourceLoader extends jsdom.ResourceLoader {
+  fetch(url, options) {
+    if (options.element) {
+      console.log(`Element ${options.element.localName} is requesting the url ${url}`);
+    }
+
+    return super.fetch(url, options);
+  }
+}
+```
+
+### Virtual consoles
+
+Like web browsers, jsdom has the concept of a "console". This records both information directly sent from the page, via scripts executing inside the document, as well as information from the jsdom implementation itself. We call the user-controllable console a "virtual console", to distinguish it from the Node.js `console` API and from the inside-the-page `window.console` API.
+
+By default, the `JSDOM` constructor will return an instance with a virtual console that forwards all its output to the Node.js console. To create your own virtual console and pass it to jsdom, you can override this default by doing
+
+```js
+const virtualConsole = new jsdom.VirtualConsole();
+const dom = new JSDOM(``, { virtualConsole });
+```
+
+Code like this will create a virtual console with no behavior. You can give it behavior by adding event listeners for all the possible console methods:
+
+```js
+virtualConsole.on("error", () => { ... });
+virtualConsole.on("warn", () => { ... });
+virtualConsole.on("info", () => { ... });
+virtualConsole.on("dir", () => { ... });
+// ... etc. See https://console.spec.whatwg.org/#logging
+```
+
+(Note that it is probably best to set up these event listeners *before* calling `new JSDOM()`, since errors or console-invoking script might occur during parsing.)
+
+If you simply want to redirect the virtual console output to another console, like the default Node.js one, you can do
+
+```js
+virtualConsole.sendTo(console);
+```
+
+There is also a special event, `"jsdomError"`, which will fire with error objects to report errors from jsdom itself. This is similar to how error messages often show up in web browser consoles, even if they are not initiated by `console.error`. So far, the following errors are output this way:
+
+- Errors loading or parsing subresources (scripts, stylesheets, frames, and iframes)
+- Script execution errors that are not handled by a window `onerror` event handler that returns `true` or calls `event.preventDefault()`
+- Not-implemented errors resulting from calls to methods, like `window.alert`, which jsdom does not implement, but installs anyway for web compatibility
+
+If you're using `sendTo(c)` to send errors to `c`, by default it will call `c.error(errorStack[, errorDetail])` with information from `"jsdomError"` events. If you'd prefer to maintain a strict one-to-one mapping of events to method calls, and perhaps handle `"jsdomError"`s yourself, then you can do
+
+```js
+virtualConsole.sendTo(c, { omitJSDOMErrors: true });
+```
+
+### Cookie jars
+
+Like web browsers, jsdom has the concept of a cookie jar, storing HTTP cookies. Cookies that have a URL on the same domain as the document, and are not marked HTTP-only, are accessible via the `document.cookie` API. Additionally, all cookies in the cookie jar will impact the fetching of subresources.
+
+By default, the `JSDOM` constructor will return an instance with an empty cookie jar. To create your own cookie jar and pass it to jsdom, you can override this default by doing
+
+```js
+const cookieJar = new jsdom.CookieJar(store, options);
+const dom = new JSDOM(``, { cookieJar });
+```
+
+This is mostly useful if you want to share the same cookie jar among multiple jsdoms, or prime the cookie jar with certain values ahead of time.
+
+Cookie jars are provided by the [tough-cookie](https://www.npmjs.com/package/tough-cookie) package. The `jsdom.CookieJar` constructor is a subclass of the tough-cookie cookie jar which by default sets the `looseMode: true` option, since that [matches better how browsers behave](https://github.com/whatwg/html/issues/804). If you want to use tough-cookie's utilities and classes yourself, you can use the `jsdom.toughCookie` module export to get access to the tough-cookie module instance packaged with jsdom.
+
+### Intervening before parsing
+
+jsdom allows you to intervene in the creation of a jsdom very early: after the `Window` and `Document` objects are created, but before any HTML is parsed to populate the document with nodes:
+
+```js
+const dom = new JSDOM(`<p>Hello</p>`, {
+  beforeParse(window) {
+    window.document.childNodes.length === 0;
+    window.someCoolAPI = () => { /* ... */ };
+  }
+});
+```
+
+This is especially useful if you are wanting to modify the environment in some way, for example adding shims for web platform APIs jsdom does not support.
+
+## `JSDOM` object API
+
+Once you have constructed a `JSDOM` object, it will have the following useful capabilities:
+
+### Properties
+
+The property `window` retrieves the `Window` object that was created for you.
+
+The properties `virtualConsole` and `cookieJar` reflect the options you pass in, or the defaults created for you if nothing was passed in for those options.
+
+### Serializing the document with `serialize()`
+
+The `serialize()` method will return the [HTML serialization](https://html.spec.whatwg.org/#html-fragment-serialisation-algorithm) of the document, including the doctype:
+
+```js
+const dom = new JSDOM(`<!DOCTYPE html>hello`);
+
+dom.serialize() === "<!DOCTYPE html><html><head></head><body>hello</body></html>";
+
+// Contrast with:
+dom.window.document.documentElement.outerHTML === "<html><head></head><body>hello</body></html>";
+```
+
+### Getting the source location of a node with `nodeLocation(node)`
+
+The `nodeLocation()` method will find where a DOM node is within the source document, returning the [parse5 location info](https://www.npmjs.com/package/parse5#options-locationinfo) for the node:
+
+```js
+const dom = new JSDOM(
+  `<p>Hello
+    <img src="foo.jpg">
+  </p>`,
+  { includeNodeLocations: true }
+);
+
+const document = dom.window.document;
+const bodyEl = document.body; // implicitly created
+const pEl = document.querySelector("p");
+const textNode = pEl.firstChild;
+const imgEl = document.querySelector("img");
+
+console.log(dom.nodeLocation(bodyEl));   // null; it's not in the source
+console.log(dom.nodeLocation(pEl));      // { startOffset: 0, endOffset: 39, startTag: ..., endTag: ... }
+console.log(dom.nodeLocation(textNode)); // { startOffset: 3, endOffset: 13 }
+console.log(dom.nodeLocation(imgEl));    // { startOffset: 13, endOffset: 32 }
+```
+
+Note that this feature only works if you have set the `includeNodeLocations` option; node locations are off by default for performance reasons.
+
+### Interfacing with the Node.js `vm` module using `getInternalVMContext()`
+
+The built-in [`vm`](https://nodejs.org/api/vm.html) module of Node.js is what underpins jsdom's script-running magic. Some advanced use cases, like pre-compiling a script and then running it multiple times, benefit from using the `vm` module directly with a jsdom-created `Window`.
+
+To get access to the [contextified global object](https://nodejs.org/api/vm.html#vm_what_does_it_mean_to_contextify_an_object), suitable for use with the `vm` APIs, you can use the `getInternalVMContext()` method:
+
+```js
+const { Script } = require("vm");
+
+const dom = new JSDOM(``, { runScripts: "outside-only" });
+const script = new Script(`
+  if (!this.ran) {
+    this.ran = 0;
+  }
+
+  ++this.ran;
+`);
+
+const vmContext = dom.getInternalVMContext();
+
+script.runInContext(vmContext);
+script.runInContext(vmContext);
+script.runInContext(vmContext);
+
+console.assert(dom.window.ran === 3);
+```
+
+This is somewhat-advanced functionality, and we advise sticking to normal DOM APIs (such as `window.eval()` or `document.createElement("script")`) unless you have very specific needs.
+
+Note that this method will throw an exception if the `JSDOM` instance was created without `runScripts` set, or if you are [using jsdom in a web browser](#running-jsdom-inside-a-web-browser).
+
+### Reconfiguring the jsdom with `reconfigure(settings)`
+
+The `top` property on `window` is marked `[Unforgeable]` in the spec, meaning it is a non-configurable own property and thus cannot be overridden or shadowed by normal code running inside the jsdom, even using `Object.defineProperty`.
+
+Similarly, at present jsdom does not handle navigation (such as setting `window.location.href = "https://example.com/"`); doing so will cause the virtual console to emit a `"jsdomError"` explaining that this feature is not implemented, and nothing will change: there will be no new `Window` or `Document` object, and the existing `window`'s `location` object will still have all the same property values.
+
+However, if you're acting from outside the window, e.g. in some test framework that creates jsdoms, you can override one or both of these using the special `reconfigure()` method:
+
+```js
+const dom = new JSDOM();
+
+dom.window.top === dom.window;
+dom.window.location.href === "about:blank";
+
+dom.reconfigure({ windowTop: myFakeTopForTesting, url: "https://example.com/" });
+
+dom.window.top === myFakeTopForTesting;
+dom.window.location.href === "https://example.com/";
+```
+
+Note that changing the jsdom's URL will impact all APIs that return the current document URL, such as `window.location`, `document.URL`, and `document.documentURI`, as well as the resolution of relative URLs within the document, and the same-origin checks and referrer used while fetching subresources. It will not, however, perform navigation to the contents of that URL; the contents of the DOM will remain unchanged, and no new instances of `Window`, `Document`, etc. will be created.
+
+## Convenience APIs
+
+### `fromURL()`
+
+In addition to the `JSDOM` constructor itself, jsdom provides a promise-returning factory method for constructing a jsdom from a URL:
+
+```js
+JSDOM.fromURL("https://example.com/", options).then(dom => {
+  console.log(dom.serialize());
+});
+```
+
+The returned promise will fulfill with a `JSDOM` instance if the URL is valid and the request is successful. Any redirects will be followed to their ultimate destination.
+
+The options provided to `fromURL()` are similar to those provided to the `JSDOM` constructor, with the following additional restrictions and consequences:
+
+- The `url` and `contentType` options cannot be provided.
+- The `referrer` option is used as the HTTP `Referer` request header of the initial request.
+- The `resources` option also affects the initial request; this is useful if you want to, for example, configure a proxy (see above).
+- The resulting jsdom's URL, content type, and referrer are determined from the response.
+- Any cookies set via HTTP `Set-Cookie` response headers are stored in the jsdom's cookie jar. Similarly, any cookies already in a supplied cookie jar are sent as HTTP `Cookie` request headers.
+
+### `fromFile()`
+
+Similar to `fromURL()`, jsdom also provides a `fromFile()` factory method for constructing a jsdom from a filename:
+
+```js
+JSDOM.fromFile("stuff.html", options).then(dom => {
+  console.log(dom.serialize());
+});
+```
+
+The returned promise will fulfill with a `JSDOM` instance if the given file can be opened. As usual in Node.js APIs, the filename is given relative to the current working directory.
+
+The options provided to `fromFile()` are similar to those provided to the `JSDOM` constructor, with the following additional defaults:
+
+- The `url` option will default to a file URL corresponding to the given filename, instead of to `"about:blank"`.
+- The `contentType` option will default to `"application/xhtml+xml"` if the given filename ends in `.xht`, `.xhtml`, or `.xml`; otherwise it will continue to default to `"text/html"`.
+
+### `fragment()`
+
+For the very simplest of cases, you might not need a whole `JSDOM` instance with all its associated power. You might not even need a `Window` or `Document`! Instead, you just need to parse some HTML, and get a DOM object you can manipulate. For that, we have `fragment()`, which creates a `DocumentFragment` from a given string:
+
+```js
+const frag = JSDOM.fragment(`<p>Hello</p><p><strong>Hi!</strong>`);
+
+frag.childNodes.length === 2;
+frag.querySelector("strong").textContent === "Hi!";
+// etc.
+```
+
+Here `frag` is a [`DocumentFragment`](https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment) instance, whose contents are created by parsing the provided string. The parsing is done using a `<template>` element, so you can include any element there (including ones with weird parsing rules like `<td>`). It's also important to note that the resulting `DocumentFragment` will not have [an associated browsing context](https://html.spec.whatwg.org/multipage/#concept-document-bc): that is, elements' `ownerDocument` will have a null `defaultView` property, resources will not load, etc.
+
+All invocations of the `fragment()` factory result in `DocumentFragment`s that share the same template owner `Document`. This allows many calls to `fragment()` with no extra overhead. But it also means that calls to `fragment()` cannot be customized with any options.
+
+Note that serialization is not as easy with `DocumentFragment`s as it is with full `JSDOM` objects. If you need to serialize your DOM, you should probably use the `JSDOM` constructor more directly. But for the special case of a fragment containing a single element, it's pretty easy to do through normal means:
+
+```js
+const frag = JSDOM.fragment(`<p>Hello</p>`);
+console.log(frag.firstChild.outerHTML); // logs "<p>Hello</p>"
+```
+
+## Other noteworthy features
+
+### Canvas support
+
+jsdom includes support for using the [`canvas`](https://www.npmjs.com/package/canvas) package to extend any `<canvas>` elements with the canvas API. To make this work, you need to include `canvas` as a dependency in your project, as a peer of `jsdom`. If jsdom can find the `canvas` package, it will use it, but if it's not present, then `<canvas>` elements will behave like `<div>`s. Since jsdom v13, version 2.x of `canvas` is required; version 1.x is no longer supported.
+
+### Encoding sniffing
+
+In addition to supplying a string, the `JSDOM` constructor can also be supplied binary data, in the form of a Node.js [`Buffer`](https://nodejs.org/docs/latest/api/buffer.html) or a standard JavaScript binary data type like `ArrayBuffer`, `Uint8Array`, `DataView`, etc. When this is done, jsdom will [sniff the encoding](https://html.spec.whatwg.org/multipage/syntax.html#encoding-sniffing-algorithm) from the supplied bytes, scanning for `<meta charset>` tags just like a browser does.
+
+If the supplied `contentType` option contains a `charset` parameter, that encoding will override the sniffed encoding—unless a UTF-8 or UTF-16 BOM is present, in which case those take precedence. (Again, this is just like a browser.)
+
+This encoding sniffing also applies to `JSDOM.fromFile()` and `JSDOM.fromURL()`. In the latter case, any `Content-Type` headers sent with the response will take priority, in the same fashion as the constructor's `contentType` option.
+
+Note that in many cases supplying bytes in this fashion can be better than supplying a string. For example, if you attempt to use Node.js's `buffer.toString("utf-8")` API, Node.js will not strip any leading BOMs. If you then give this string to jsdom, it will interpret it verbatim, leaving the BOM intact. But jsdom's binary data decoding code will strip leading BOMs, just like a browser; in such cases, supplying `buffer` directly will give the desired result.
+
+### Closing down a jsdom
+
+Timers in the jsdom (set by `window.setTimeout()` or `window.setInterval()`) will, by definition, execute code in the future in the context of the window. Since there is no way to execute code in the future without keeping the process alive, outstanding jsdom timers will keep your Node.js process alive. Similarly, since there is no way to execute code in the context of an object without keeping that object alive, outstanding jsdom timers will prevent garbage collection of the window on which they are scheduled.
+
+If you want to be sure to shut down a jsdom window, use `window.close()`, which will terminate all running timers (and also remove any event listeners on the window and document).
+
+### Running jsdom inside a web browser
+
+jsdom has some support for being run inside a web browser, using [browserify](https://browserify.org/). That is, inside a web browser, you can use a browserified jsdom to create an entirely self-contained set of plain JavaScript objects which look and act much like the browser's existing DOM objects, while being entirely independent of them. "Virtual DOM", indeed!
+
+jsdom's primary target is still Node.js, and so we use language features that are only present in recent Node.js versions (namely, Node.js v8+). Thus, older browsers will likely not work. (Even transpilation will not help: we use `Proxy`s extensively throughout the jsdom codebase.)
+
+Notably, jsdom works well inside a web worker. The original contributor, [@lawnsea](https://github.com/lawnsea/), who made this possible, has [published a paper](https://pdfs.semanticscholar.org/47f0/6bb6607a975500a30e9e52d7c9fbc0034e27.pdf) about his project which uses this capability.
+
+Not everything works perfectly when running jsdom inside a web browser. Sometimes that is because of fundamental limitations (such as not having filesystem access), but sometimes it is simply because we haven't spent enough time making the appropriate small tweaks. Bug reports are certainly welcome.
+
+### Debugging the DOM using Chrome Devtools
+
+As of Node.js v6 you can debug programs using Chrome Devtools. See the [official documentation](https://nodejs.org/en/docs/inspector/) for how to get started.
+
+By default jsdom elements are formatted as plain old JS objects in the console. To make it easier to debug, you can use [jsdom-devtools-formatter](https://github.com/viddo/jsdom-devtools-formatter), which lets you inspect them like real DOM elements.
+
+## Caveats
+
+### Asynchronous script loading
+
+People often have trouble with asynchronous script loading when using jsdom. Many pages load scripts asynchronously, but there is no way to tell when they're done doing so, and thus when it's a good time to run your code and inspect the resulting DOM structure. This is a fundamental limitation; we cannot predict what scripts on the web page will do, and so cannot tell you when they are done loading more scripts.
+
+This can be worked around in a few ways. The best way, if you control the page in question, is to use whatever mechanisms are given by the script loader to detect when loading is done. For example, if you're using a module loader like RequireJS, the code could look like:
+
+```js
+// On the Node.js side:
+const window = (new JSDOM(...)).window;
+window.onModulesLoaded = () => {
+  console.log("ready to roll!");
+};
+```
+
+```html
+<!-- Inside the HTML you supply to jsdom -->
+<script>
+requirejs(["entry-module"], () => {
+  window.onModulesLoaded();
+});
+</script>
+```
+
+If you do not control the page, you could try workarounds such as polling for the presence of a specific element.
+
+For more details, see the discussion in [#640](https://github.com/jsdom/jsdom/issues/640), especially [@matthewkastor](https://github.com/matthewkastor)'s [insightful comment](https://github.com/jsdom/jsdom/issues/640#issuecomment-22216965).
+
+### Unimplemented parts of the web platform
+
+Although we enjoy adding new features to jsdom and keeping it up to date with the latest web specs, it has many missing APIs. Please feel free to file an issue for anything missing, but we're a small and busy team, so a pull request might work even better.
+
+Beyond just features that we haven't gotten to yet, there are two major features that are currently outside the scope of jsdom. These are:
+
+- **Navigation**: the ability to change the global object, and all other objects, when clicking a link or assigning `location.href` or similar.
+- **Layout**: the ability to calculate where elements will be visually laid out as a result of CSS, which impacts methods like `getBoundingClientRects()` or properties like `offsetTop`.
+
+Currently jsdom has dummy behaviors for some aspects of these features, such as sending a "not implemented" `"jsdomError"` to the virtual console for navigation, or returning zeros for many layout-related properties. Often you can work around these limitations in your code, e.g. by creating new `JSDOM` instances for each page you "navigate" to during a crawl, or using `Object.defineProperty()` to change what various layout-related getters and methods return.
+
+Note that other tools in the same space, such as PhantomJS, do support these features. On the wiki, we have a more complete writeup about [jsdom vs. PhantomJS](https://github.com/jsdom/jsdom/wiki/jsdom-vs.-PhantomJS).
+
+## Supporting jsdom
+
+jsdom is a community-driven project maintained by a team of [volunteers](https://github.com/orgs/jsdom/people). You could support jsdom by:
+
+- [Getting professional support for jsdom](https://tidelift.com/subscription/pkg/npm-jsdom?utm_source=npm-jsdom&utm_medium=referral&utm_campaign=readme) as part of a Tidelift subscription. Tidelift helps making open source sustainable for us while giving teams assurances for maintenance, licensing, and security.
+- [Contributing](https://github.com/jsdom/jsdom/blob/master/Contributing.md) directly to the project.
+
+## Getting help
+
+If you need help with jsdom, please feel free to use any of the following venues:
+
+- The [mailing list](http://groups.google.com/group/jsdom) (best for "how do I" questions)
+- The [issue tracker](https://github.com/jsdom/jsdom/issues) (best for bug reports)
+- The IRC channel: [#jsdom on freenode](irc://irc.freenode.net/jsdom)
diff --git a/lib/api.js b/lib/api.js
new file mode 100644
index 0000000..1a8bbeb
--- /dev/null
+++ b/lib/api.js
@@ -0,0 +1,335 @@
+"use strict";
+const path = require("path");
+const fs = require("fs").promises;
+const vm = require("vm");
+const toughCookie = require("tough-cookie");
+const sniffHTMLEncoding = require("html-encoding-sniffer");
+const whatwgURL = require("whatwg-url");
+const whatwgEncoding = require("whatwg-encoding");
+const { URL } = require("whatwg-url");
+const MIMEType = require("whatwg-mimetype");
+const idlUtils = require("./jsdom/living/generated/utils.js");
+const VirtualConsole = require("./jsdom/virtual-console.js");
+const { createWindow } = require("./jsdom/browser/Window.js");
+const { parseIntoDocument } = require("./jsdom/browser/parser");
+const { fragmentSerialization } = require("./jsdom/living/domparsing/serialization.js");
+const ResourceLoader = require("./jsdom/browser/resources/resource-loader.js");
+const NoOpResourceLoader = require("./jsdom/browser/resources/no-op-resource-loader.js");
+
+class CookieJar extends toughCookie.CookieJar {
+  constructor(store, options) {
+    // jsdom cookie jars must be loose by default
+    super(store, Object.assign({ looseMode: true }, options));
+  }
+}
+
+const window = Symbol("window");
+let sharedFragmentDocument = null;
+
+class JSDOM {
+  constructor(input, options = {}) {
+    const mimeType = new MIMEType(options.contentType === undefined ? "text/html" : options.contentType);
+    const { html, encoding } = normalizeHTML(input, mimeType);
+
+    options = transformOptions(options, encoding, mimeType);
+
+    this[window] = createWindow(options.windowOptions);
+
+    const documentImpl = idlUtils.implForWrapper(this[window]._document);
+
+    options.beforeParse(this[window]._globalProxy);
+
+    parseIntoDocument(html, documentImpl);
+
+    documentImpl.close();
+  }
+
+  get window() {
+    // It's important to grab the global proxy, instead of just the result of `createWindow(...)`, since otherwise
+    // things like `window.eval` don't exist.
+    return this[window]._globalProxy;
+  }
+
+  get virtualConsole() {
+    return this[window]._virtualConsole;
+  }
+
+  get cookieJar() {
+    // TODO NEWAPI move _cookieJar to window probably
+    return idlUtils.implForWrapper(this[window]._document)._cookieJar;
+  }
+
+  serialize() {
+    return fragmentSerialization(idlUtils.implForWrapper(this[window]._document), { requireWellFormed: false });
+  }
+
+  nodeLocation(node) {
+    if (!idlUtils.implForWrapper(this[window]._document)._parseOptions.sourceCodeLocationInfo) {
+      throw new Error("Location information was not saved for this jsdom. Use includeNodeLocations during creation.");
+    }
+
+    return idlUtils.implForWrapper(node).sourceCodeLocation;
+  }
+
+  getInternalVMContext() {
+    if (!vm.isContext(this[window])) {
+      throw new TypeError("This jsdom was not configured to allow script running. " +
+        "Use the runScripts option during creation.");
+    }
+
+    return this[window];
+  }
+
+  reconfigure(settings) {
+    if ("windowTop" in settings) {
+      this[window]._top = settings.windowTop;
+    }
+
+    if ("url" in settings) {
+      const document = idlUtils.implForWrapper(this[window]._document);
+
+      const url = whatwgURL.parseURL(settings.url);
+      if (url === null) {
+        throw new TypeError(`Could not parse "${settings.url}" as a URL`);
+      }
+
+      document._URL = url;
+      document._origin = whatwgURL.serializeURLOrigin(document._URL);
+    }
+  }
+
+  static fragment(string = "") {
+    if (!sharedFragmentDocument) {
+      sharedFragmentDocument = (new JSDOM()).window.document;
+    }
+
+    const template = sharedFragmentDocument.createElement("template");
+    template.innerHTML = string;
+    return template.content;
+  }
+
+  static fromURL(url, options = {}) {
+    return Promise.resolve().then(() => {
+      // Remove the hash while sending this through the research loader fetch().
+      // It gets added back a few lines down when constructing the JSDOM object.
+      const parsedURL = new URL(url);
+      const originalHash = parsedURL.hash;
+      parsedURL.hash = "";
+      url = parsedURL.href;
+
+      options = normalizeFromURLOptions(options);
+
+      const resourceLoader = resourcesToResourceLoader(options.resources);
+      const resourceLoaderForInitialRequest = resourceLoader.constructor === NoOpResourceLoader ?
+        new ResourceLoader() :
+        resourceLoader;
+
+      const req = resourceLoaderForInitialRequest.fetch(url, {
+        accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        cookieJar: options.cookieJar,
+        referrer: options.referrer
+      });
+
+      return req.then(body => {
+        const res = req.response;
+
+        options = Object.assign(options, {
+          url: req.href + originalHash,
+          contentType: res.headers["content-type"],
+          referrer: req.getHeader("referer")
+        });
+
+        return new JSDOM(body, options);
+      });
+    });
+  }
+
+  static async fromFile(filename, options = {}) {
+    options = normalizeFromFileOptions(filename, options);
+    const buffer = await fs.readFile(filename);
+
+    return new JSDOM(buffer, options);
+  }
+}
+
+function normalizeFromURLOptions(options) {
+  // Checks on options that are invalid for `fromURL`
+  if (options.url !== undefined) {
+    throw new TypeError("Cannot supply a url option when using fromURL");
+  }
+  if (options.contentType !== undefined) {
+    throw new TypeError("Cannot supply a contentType option when using fromURL");
+  }
+
+  // Normalization of options which must be done before the rest of the fromURL code can use them, because they are
+  // given to request()
+  const normalized = Object.assign({}, options);
+
+  if (options.referrer !== undefined) {
+    normalized.referrer = (new URL(options.referrer)).href;
+  }
+
+  if (options.cookieJar === undefined) {
+    normalized.cookieJar = new CookieJar();
+  }
+
+  return normalized;
+
+  // All other options don't need to be processed yet, and can be taken care of in the normal course of things when
+  // `fromURL` calls `new JSDOM(html, options)`.
+}
+
+function normalizeFromFileOptions(filename, options) {
+  const normalized = Object.assign({}, options);
+
+  if (normalized.contentType === undefined) {
+    const extname = path.extname(filename);
+    if (extname === ".xhtml" || extname === ".xht" || extname === ".xml") {
+      normalized.contentType = "application/xhtml+xml";
+    }
+  }
+
+  if (normalized.url === undefined) {
+    normalized.url = new URL("file:" + path.resolve(filename));
+  }
+
+  return normalized;
+}
+
+function transformOptions(options, encoding, mimeType) {
+  const transformed = {
+    windowOptions: {
+      // Defaults
+      url: "about:blank",
+      referrer: "",
+      contentType: "text/html",
+      parsingMode: "html",
+      parseOptions: {
+        sourceCodeLocationInfo: false,
+        scriptingEnabled: false
+      },
+      runScripts: undefined,
+      encoding,
+      pretendToBeVisual: false,
+      storageQuota: 5000000,
+
+      // Defaults filled in later
+      resourceLoader: undefined,
+      virtualConsole: undefined,
+      cookieJar: undefined
+    },
+
+    // Defaults
+    beforeParse() { }
+  };
+
+  // options.contentType was parsed into mimeType by the caller.
+  if (!mimeType.isHTML() && !mimeType.isXML()) {
+    throw new RangeError(`The given content type of "${options.contentType}" was not a HTML or XML content type`);
+  }
+
+  transformed.windowOptions.contentType = mimeType.essence;
+  transformed.windowOptions.parsingMode = mimeType.isHTML() ? "html" : "xml";
+
+  if (options.url !== undefined) {
+    transformed.windowOptions.url = (new URL(options.url)).href;
+  }
+
+  if (options.referrer !== undefined) {
+    transformed.windowOptions.referrer = (new URL(options.referrer)).href;
+  }
+
+  if (options.includeNodeLocations) {
+    if (transformed.windowOptions.parsingMode === "xml") {
+      throw new TypeError("Cannot set includeNodeLocations to true with an XML content type");
+    }
+
+    transformed.windowOptions.parseOptions = { sourceCodeLocationInfo: true };
+  }
+
+  transformed.windowOptions.cookieJar = options.cookieJar === undefined ?
+                                       new CookieJar() :
+                                       options.cookieJar;
+
+  transformed.windowOptions.virtualConsole = options.virtualConsole === undefined ?
+                                            (new VirtualConsole()).sendTo(console) :
+                                            options.virtualConsole;
+
+  if (!(transformed.windowOptions.virtualConsole instanceof VirtualConsole)) {
+    throw new TypeError("virtualConsole must be an instance of VirtualConsole");
+  }
+
+  transformed.windowOptions.resourceLoader = resourcesToResourceLoader(options.resources);
+
+  if (options.runScripts !== undefined) {
+    transformed.windowOptions.runScripts = String(options.runScripts);
+    if (transformed.windowOptions.runScripts === "dangerously") {
+      transformed.windowOptions.parseOptions.scriptingEnabled = true;
+    } else if (transformed.windowOptions.runScripts !== "outside-only") {
+      throw new RangeError(`runScripts must be undefined, "dangerously", or "outside-only"`);
+    }
+  }
+
+  if (options.beforeParse !== undefined) {
+    transformed.beforeParse = options.beforeParse;
+  }
+
+  if (options.pretendToBeVisual !== undefined) {
+    transformed.windowOptions.pretendToBeVisual = Boolean(options.pretendToBeVisual);
+  }
+
+  if (options.storageQuota !== undefined) {
+    transformed.windowOptions.storageQuota = Number(options.storageQuota);
+  }
+
+  // concurrentNodeIterators??
+
+  return transformed;
+}
+
+function normalizeHTML(html = "", mimeType) {
+  let encoding = "UTF-8";
+
+  if (ArrayBuffer.isView(html)) {
+    html = Buffer.from(html.buffer, html.byteOffset, html.byteLength);
+  } else if (html instanceof ArrayBuffer) {
+    html = Buffer.from(html);
+  }
+
+  if (Buffer.isBuffer(html)) {
+    encoding = sniffHTMLEncoding(html, {
+      defaultEncoding: mimeType.isXML() ? "UTF-8" : "windows-1252",
+      transportLayerEncodingLabel: mimeType.parameters.get("charset")
+    });
+    html = whatwgEncoding.decode(html, encoding);
+  } else {
+    html = String(html);
+  }
+
+  return { html, encoding };
+}
+
+function resourcesToResourceLoader(resources) {
+  switch (resources) {
+    case undefined: {
+      return new NoOpResourceLoader();
+    }
+    case "usable": {
+      return new ResourceLoader();
+    }
+    default: {
+      if (!(resources instanceof ResourceLoader)) {
+        throw new TypeError("resources must be an instance of ResourceLoader");
+      }
+      return resources;
+    }
+  }
+}
+
+exports.JSDOM = JSDOM;
+
+exports.VirtualConsole = VirtualConsole;
+exports.CookieJar = CookieJar;
+exports.ResourceLoader = ResourceLoader;
+
+exports.toughCookie = toughCookie;
diff --git a/lib/jsdom/browser/Window.js b/lib/jsdom/browser/Window.js
new file mode 100644
index 0000000..968c1af
--- /dev/null
+++ b/lib/jsdom/browser/Window.js
@@ -0,0 +1,779 @@
+"use strict";
+const vm = require("vm");
+const webIDLConversions = require("webidl-conversions");
+const { CSSStyleDeclaration } = require("cssstyle");
+const { Performance: RawPerformance } = require("w3c-hr-time");
+const notImplemented = require("./not-implemented");
+const { installInterfaces } = require("../living/interfaces");
+const { define, mixin } = require("../utils");
+const Element = require("../living/generated/Element");
+const EventTarget = require("../living/generated/EventTarget");
+const PageTransitionEvent = require("../living/generated/PageTransitionEvent");
+const namedPropertiesWindow = require("../living/named-properties-window");
+const postMessage = require("../living/post-message");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { btoa, atob } = require("abab");
+const idlUtils = require("../living/generated/utils");
+const WebSocketImpl = require("../living/websockets/WebSocket-impl").implementation;
+const BarProp = require("../living/generated/BarProp");
+const Document = require("../living/generated/Document");
+const External = require("../living/generated/External");
+const Navigator = require("../living/generated/Navigator");
+const Performance = require("../living/generated/Performance");
+const Screen = require("../living/generated/Screen");
+const Storage = require("../living/generated/Storage");
+const Selection = require("../living/generated/Selection");
+const reportException = require("../living/helpers/runtime-script-errors");
+const { fireAnEvent } = require("../living/helpers/events");
+const SessionHistory = require("../living/window/SessionHistory");
+const { forEachMatchingSheetRuleOfElement, getResolvedValue, propertiesWithResolvedValueImplemented } =
+  require("../living/helpers/style-rules");
+const CustomElementRegistry = require("../living/generated/CustomElementRegistry");
+const jsGlobals = require("./js-globals.json");
+
+const GlobalEventHandlersImpl = require("../living/nodes/GlobalEventHandlers-impl").implementation;
+const WindowEventHandlersImpl = require("../living/nodes/WindowEventHandlers-impl").implementation;
+
+exports.createWindow = function (options) {
+  return new Window(options);
+};
+
+const jsGlobalEntriesToInstall = Object.entries(jsGlobals).filter(([name]) => name in global);
+
+// https://html.spec.whatwg.org/#the-window-object
+function setupWindow(windowInstance, { runScripts }) {
+  if (runScripts === "outside-only" || runScripts === "dangerously") {
+    contextifyWindow(windowInstance);
+
+    // Without this, these globals will only appear to scripts running inside the context using vm.runScript; they will
+    // not appear to scripts running from the outside, including to JSDOM implementation code.
+    for (const [globalName, globalPropDesc] of jsGlobalEntriesToInstall) {
+      const propDesc = { ...globalPropDesc, value: vm.runInContext(globalName, windowInstance) };
+      Object.defineProperty(windowInstance, globalName, propDesc);
+    }
+  } else {
+    // Without contextifying the window, none of the globals will exist. So, let's at least alias them from the Node.js
+    // context. See https://github.com/jsdom/jsdom/issues/2727 for more background and discussion.
+    for (const [globalName, globalPropDesc] of jsGlobalEntriesToInstall) {
+      const propDesc = { ...globalPropDesc, value: global[globalName] };
+      Object.defineProperty(windowInstance, globalName, propDesc);
+    }
+  }
+
+  installInterfaces(windowInstance);
+
+  const EventTargetConstructor = windowInstance.EventTarget;
+
+  // eslint-disable-next-line func-name-matching, func-style, no-shadow
+  const windowConstructor = function Window() {
+    throw new TypeError("Illegal constructor");
+  };
+  Object.setPrototypeOf(windowConstructor, EventTargetConstructor);
+
+  Object.defineProperty(windowInstance, "Window", {
+    configurable: true,
+    writable: true,
+    value: windowConstructor
+  });
+
+  const windowPrototype = Object.create(EventTargetConstructor.prototype);
+  Object.defineProperties(windowPrototype, {
+    constructor: {
+      value: windowConstructor,
+      writable: true,
+      configurable: true
+    },
+    [Symbol.toStringTag]: {
+      value: "Window",
+      configurable: true
+    }
+  });
+
+  windowConstructor.prototype = windowPrototype;
+  Object.setPrototypeOf(windowInstance, windowPrototype);
+
+  EventTarget.setup(windowInstance, windowInstance);
+  mixin(windowInstance, WindowEventHandlersImpl.prototype);
+  mixin(windowInstance, GlobalEventHandlersImpl.prototype);
+  windowInstance._initGlobalEvents();
+
+  windowInstance._globalObject = windowInstance;
+}
+
+// NOTE: per https://heycam.github.io/webidl/#Global, all properties on the Window object must be own-properties.
+// That is why we assign everything inside of the constructor, instead of using a shared prototype.
+// You can verify this in e.g. Firefox or Internet Explorer, which do a good job with Web IDL compliance.
+function Window(options) {
+  setupWindow(this, { runScripts: options.runScripts });
+
+  const rawPerformance = new RawPerformance();
+  const windowInitialized = rawPerformance.now();
+
+  const window = this;
+
+  ///// PRIVATE DATA PROPERTIES
+
+  this._resourceLoader = options.resourceLoader;
+
+  // vm initialization is deferred until script processing is activated
+  this._globalProxy = this;
+  Object.defineProperty(idlUtils.implForWrapper(this), idlUtils.wrapperSymbol, { get: () => this._globalProxy });
+
+  // List options explicitly to be clear which are passed through
+  this._document = Document.create(window, [], {
+    options: {
+      parsingMode: options.parsingMode,
+      contentType: options.contentType,
+      encoding: options.encoding,
+      cookieJar: options.cookieJar,
+      url: options.url,
+      lastModified: options.lastModified,
+      referrer: options.referrer,
+      concurrentNodeIterators: options.concurrentNodeIterators,
+      parseOptions: options.parseOptions,
+      defaultView: this._globalProxy,
+      global: this
+    }
+  });
+
+  if (vm.isContext(window)) {
+    const documentImpl = idlUtils.implForWrapper(window._document);
+    documentImpl._defaultView = window._globalProxy = vm.runInContext("this", window);
+  }
+
+  const documentOrigin = idlUtils.implForWrapper(this._document)._origin;
+  this._origin = documentOrigin;
+
+  // https://html.spec.whatwg.org/#session-history
+  this._sessionHistory = new SessionHistory({
+    document: idlUtils.implForWrapper(this._document),
+    url: idlUtils.implForWrapper(this._document)._URL,
+    stateObject: null
+  }, this);
+
+  this._virtualConsole = options.virtualConsole;
+
+  this._runScripts = options.runScripts;
+
+  // Set up the window as if it's a top level window.
+  // If it's not, then references will be corrected by frame/iframe code.
+  this._parent = this._top = this._globalProxy;
+  this._frameElement = null;
+
+  // This implements window.frames.length, since window.frames returns a
+  // self reference to the window object.  This value is incremented in the
+  // HTMLFrameElement implementation.
+  this._length = 0;
+
+  this._pretendToBeVisual = options.pretendToBeVisual;
+  this._storageQuota = options.storageQuota;
+
+  // Some properties (such as localStorage and sessionStorage) share data
+  // between windows in the same origin. This object is intended
+  // to contain such data.
+  if (options.commonForOrigin && options.commonForOrigin[documentOrigin]) {
+    this._commonForOrigin = options.commonForOrigin;
+  } else {
+    this._commonForOrigin = {
+      [documentOrigin]: {
+        localStorageArea: new Map(),
+        sessionStorageArea: new Map(),
+        windowsInSameOrigin: [this]
+      }
+    };
+  }
+
+  this._currentOriginData = this._commonForOrigin[documentOrigin];
+
+  ///// WEB STORAGE
+
+  this._localStorage = Storage.create(window, [], {
+    associatedWindow: this,
+    storageArea: this._currentOriginData.localStorageArea,
+    type: "localStorage",
+    url: this._document.documentURI,
+    storageQuota: this._storageQuota
+  });
+  this._sessionStorage = Storage.create(window, [], {
+    associatedWindow: this,
+    storageArea: this._currentOriginData.sessionStorageArea,
+    type: "sessionStorage",
+    url: this._document.documentURI,
+    storageQuota: this._storageQuota
+  });
+
+  ///// SELECTION
+
+  // https://w3c.github.io/selection-api/#dfn-selection
+  this._selection = Selection.createImpl(window);
+
+  // https://w3c.github.io/selection-api/#dom-window
+  this.getSelection = function () {
+    return window._selection;
+  };
+
+  ///// GETTERS
+
+  const locationbar = BarProp.create(window);
+  const menubar = BarProp.create(window);
+  const personalbar = BarProp.create(window);
+  const scrollbars = BarProp.create(window);
+  const statusbar = BarProp.create(window);
+  const toolbar = BarProp.create(window);
+  const external = External.create(window);
+  const navigator = Navigator.create(window, [], { userAgent: this._resourceLoader._userAgent });
+  const performance = Performance.create(window, [], { rawPerformance });
+  const screen = Screen.create(window);
+  const customElementRegistry = CustomElementRegistry.create(window);
+
+  define(this, {
+    get length() {
+      return window._length;
+    },
+    get window() {
+      return window._globalProxy;
+    },
+    get frameElement() {
+      return idlUtils.wrapperForImpl(window._frameElement);
+    },
+    get frames() {
+      return window._globalProxy;
+    },
+    get self() {
+      return window._globalProxy;
+    },
+    get parent() {
+      return window._parent;
+    },
+    get top() {
+      return window._top;
+    },
+    get document() {
+      return window._document;
+    },
+    get external() {
+      return external;
+    },
+    get location() {
+      return idlUtils.wrapperForImpl(idlUtils.implForWrapper(window._document)._location);
+    },
+    get history() {
+      return idlUtils.wrapperForImpl(idlUtils.implForWrapper(window._document)._history);
+    },
+    get navigator() {
+      return navigator;
+    },
+    get locationbar() {
+      return locationbar;
+    },
+    get menubar() {
+      return menubar;
+    },
+    get personalbar() {
+      return personalbar;
+    },
+    get scrollbars() {
+      return scrollbars;
+    },
+    get statusbar() {
+      return statusbar;
+    },
+    get toolbar() {
+      return toolbar;
+    },
+    get performance() {
+      return performance;
+    },
+    get screen() {
+      return screen;
+    },
+    get origin() {
+      return window._origin;
+    },
+    // The origin IDL attribute is defined with [Replaceable].
+    set origin(value) {
+      Object.defineProperty(this, "origin", {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    },
+    get localStorage() {
+      if (idlUtils.implForWrapper(this._document)._origin === "null") {
+        throw DOMException.create(window, [
+          "localStorage is not available for opaque origins",
+          "SecurityError"
+        ]);
+      }
+
+      return this._localStorage;
+    },
+    get sessionStorage() {
+      if (idlUtils.implForWrapper(this._document)._origin === "null") {
+        throw DOMException.create(window, [
+          "sessionStorage is not available for opaque origins",
+          "SecurityError"
+        ]);
+      }
+
+      return this._sessionStorage;
+    },
+    get customElements() {
+      return customElementRegistry;
+    }
+  });
+
+  namedPropertiesWindow.initializeWindow(this, this._globalProxy);
+
+  ///// METHODS for [ImplicitThis] hack
+  // See https://lists.w3.org/Archives/Public/public-script-coord/2015JanMar/0109.html
+  this.addEventListener = this.addEventListener.bind(this);
+  this.removeEventListener = this.removeEventListener.bind(this);
+  this.dispatchEvent = this.dispatchEvent.bind(this);
+
+  ///// METHODS
+
+  // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers
+
+  // In the spec the list of active timers is a set of IDs. We make it a map of IDs to Node.js timer objects, so that
+  // we can call Node.js-side clearTimeout() when clearing, and thus allow process shutdown faster.
+  const listOfActiveTimers = new Map();
+  let latestTimerId = 0;
+
+  this.setTimeout = function (handler, timeout = 0, ...args) {
+    if (typeof handler !== "function") {
+      handler = webIDLConversions.DOMString(handler);
+    }
+    timeout = webIDLConversions.long(timeout);
+
+    return timerInitializationSteps(handler, timeout, args, { methodContext: window, repeat: false });
+  };
+  this.setInterval = function (handler, timeout = 0, ...args) {
+    if (typeof handler !== "function") {
+      handler = webIDLConversions.DOMString(handler);
+    }
+    timeout = webIDLConversions.long(timeout);
+
+    return timerInitializationSteps(handler, timeout, args, { methodContext: window, repeat: true });
+  };
+
+  this.clearTimeout = function (handle = 0) {
+    handle = webIDLConversions.long(handle);
+
+    const nodejsTimer = listOfActiveTimers.get(handle);
+    if (nodejsTimer) {
+      clearTimeout(nodejsTimer);
+      listOfActiveTimers.delete(handle);
+    }
+  };
+  this.clearInterval = function (handle = 0) {
+    handle = webIDLConversions.long(handle);
+
+    const nodejsTimer = listOfActiveTimers.get(handle);
+    if (nodejsTimer) {
+      // We use setTimeout() in timerInitializationSteps even for this.setInterval().
+      clearTimeout(nodejsTimer);
+      listOfActiveTimers.delete(handle);
+    }
+  };
+
+  function timerInitializationSteps(handler, timeout, args, { methodContext, repeat, previousHandle }) {
+    // This appears to be unspecced, but matches browser behavior for close()ed windows.
+    if (!methodContext._document) {
+      return 0;
+    }
+
+    // TODO: implement timer nesting level behavior.
+
+    const methodContextProxy = methodContext._globalProxy;
+    const handle = previousHandle !== undefined ? previousHandle : ++latestTimerId;
+
+    function task() {
+      if (!listOfActiveTimers.has(handle)) {
+        return;
+      }
+
+      try {
+        if (typeof handler === "function") {
+          handler.apply(methodContextProxy, args);
+        } else if (window._runScripts === "dangerously") {
+          vm.runInContext(handler, window, { filename: window.location.href, displayErrors: false });
+        }
+      } catch (e) {
+        reportException(window, e, window.location.href);
+      }
+
+      if (repeat && listOfActiveTimers.has(handle)) {
+        timerInitializationSteps(handler, timeout, args, { methodContext, repeat: true, previousHandle: handle });
+      }
+    }
+
+    if (timeout < 0) {
+      timeout = 0;
+    }
+
+    const nodejsTimer = setTimeout(task, timeout);
+    listOfActiveTimers.set(handle, nodejsTimer);
+
+    return handle;
+  }
+
+  // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#animation-frames
+
+  let animationFrameCallbackId = 0;
+  const mapOfAnimationFrameCallbacks = new Map();
+  let animationFrameNodejsInterval = null;
+
+  // Unlike the spec, where an animation frame happens every 60 Hz regardless, we optimize so that if there are no
+  // requestAnimationFrame() calls outstanding, we don't fire the timer. This helps us track that.
+  let numberOfOngoingAnimationFrameCallbacks = 0;
+
+  if (this._pretendToBeVisual) {
+    this.requestAnimationFrame = function (callback) {
+      callback = webIDLConversions.Function(callback);
+
+      const handle = ++animationFrameCallbackId;
+      mapOfAnimationFrameCallbacks.set(handle, callback);
+
+      ++numberOfOngoingAnimationFrameCallbacks;
+      if (numberOfOngoingAnimationFrameCallbacks === 1) {
+        animationFrameNodejsInterval = setInterval(() => {
+          runAnimationFrameCallbacks(rawPerformance.now() - windowInitialized);
+        }, 1000 / 60);
+      }
+
+      return handle;
+    };
+
+    this.cancelAnimationFrame = function (handle) {
+      handle = webIDLConversions["unsigned long"](handle);
+
+      if (mapOfAnimationFrameCallbacks.has(handle)) {
+        --numberOfOngoingAnimationFrameCallbacks;
+        if (numberOfOngoingAnimationFrameCallbacks === 0) {
+          clearInterval(animationFrameNodejsInterval);
+        }
+      }
+
+      mapOfAnimationFrameCallbacks.delete(handle);
+    };
+
+    function runAnimationFrameCallbacks(now) {
+      // Converting to an array is important to get a sync snapshot and thus match spec semantics.
+      const callbackHandles = [...mapOfAnimationFrameCallbacks.keys()];
+      for (const handle of callbackHandles) {
+        // This has() can be false if a callback calls cancelAnimationFrame().
+        if (mapOfAnimationFrameCallbacks.has(handle)) {
+          const callback = mapOfAnimationFrameCallbacks.get(handle);
+          mapOfAnimationFrameCallbacks.delete(handle);
+          try {
+            callback(now);
+          } catch (e) {
+            reportException(window, e, window.location.href);
+          }
+        }
+      }
+    }
+  }
+
+  function stopAllTimers() {
+    for (const nodejsTimer of listOfActiveTimers.values()) {
+      clearTimeout(nodejsTimer);
+    }
+    listOfActiveTimers.clear();
+
+    clearInterval(animationFrameNodejsInterval);
+  }
+
+  function Option(text, value, defaultSelected, selected) {
+    if (text === undefined) {
+      text = "";
+    }
+    text = webIDLConversions.DOMString(text);
+
+    if (value !== undefined) {
+      value = webIDLConversions.DOMString(value);
+    }
+
+    defaultSelected = webIDLConversions.boolean(defaultSelected);
+    selected = webIDLConversions.boolean(selected);
+
+    const option = window._document.createElement("option");
+    const impl = idlUtils.implForWrapper(option);
+
+    if (text !== "") {
+      impl.text = text;
+    }
+    if (value !== undefined) {
+      impl.setAttributeNS(null, "value", value);
+    }
+    if (defaultSelected) {
+      impl.setAttributeNS(null, "selected", "");
+    }
+    impl._selectedness = selected;
+
+    return option;
+  }
+  Object.defineProperty(Option, "prototype", {
+    value: this.HTMLOptionElement.prototype,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  Object.defineProperty(window, "Option", {
+    value: Option,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+
+  function Image() {
+    const img = window._document.createElement("img");
+    const impl = idlUtils.implForWrapper(img);
+
+    if (arguments.length > 0) {
+      impl.setAttributeNS(null, "width", String(arguments[0]));
+    }
+    if (arguments.length > 1) {
+      impl.setAttributeNS(null, "height", String(arguments[1]));
+    }
+
+    return img;
+  }
+  Object.defineProperty(Image, "prototype", {
+    value: this.HTMLImageElement.prototype,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  Object.defineProperty(window, "Image", {
+    value: Image,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+
+  function Audio(src) {
+    const audio = window._document.createElement("audio");
+    const impl = idlUtils.implForWrapper(audio);
+    impl.setAttributeNS(null, "preload", "auto");
+
+    if (src !== undefined) {
+      impl.setAttributeNS(null, "src", String(src));
+    }
+
+    return audio;
+  }
+  Object.defineProperty(Audio, "prototype", {
+    value: this.HTMLAudioElement.prototype,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  Object.defineProperty(window, "Audio", {
+    value: Audio,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+
+  this.postMessage = postMessage(window);
+
+  this.atob = function (str) {
+    const result = atob(str);
+    if (result === null) {
+      throw DOMException.create(window, [
+        "The string to be decoded contains invalid characters.",
+        "InvalidCharacterError"
+      ]);
+    }
+    return result;
+  };
+
+  this.btoa = function (str) {
+    const result = btoa(str);
+    if (result === null) {
+      throw DOMException.create(window, [
+        "The string to be encoded contains invalid characters.",
+        "InvalidCharacterError"
+      ]);
+    }
+    return result;
+  };
+
+  this.stop = function () {
+    const manager = idlUtils.implForWrapper(this._document)._requestManager;
+    if (manager) {
+      manager.close();
+    }
+  };
+
+  this.close = function () {
+    // Recursively close child frame windows, then ourselves (depth-first).
+    for (let i = 0; i < this.length; ++i) {
+      this[i].close();
+    }
+
+    // Clear out all listeners. Any in-flight or upcoming events should not get delivered.
+    idlUtils.implForWrapper(this)._eventListeners = Object.create(null);
+
+    if (this._document) {
+      if (this._document.body) {
+        this._document.body.innerHTML = "";
+      }
+
+      if (this._document.close) {
+        // It's especially important to clear out the listeners here because document.close() causes a "load" event to
+        // fire.
+        idlUtils.implForWrapper(this._document)._eventListeners = Object.create(null);
+        this._document.close();
+      }
+      const doc = idlUtils.implForWrapper(this._document);
+      if (doc._requestManager) {
+        doc._requestManager.close();
+      }
+      delete this._document;
+    }
+
+    stopAllTimers();
+    WebSocketImpl.cleanUpWindow(this);
+  };
+
+  this.getComputedStyle = function (elt) {
+    elt = Element.convert(elt);
+
+    const declaration = new CSSStyleDeclaration();
+    const { forEach } = Array.prototype;
+    const { style } = elt;
+
+    forEachMatchingSheetRuleOfElement(elt, rule => {
+      forEach.call(rule.style, property => {
+        declaration.setProperty(
+          property,
+          rule.style.getPropertyValue(property),
+          rule.style.getPropertyPriority(property)
+        );
+      });
+    });
+
+    // https://drafts.csswg.org/cssom/#dom-window-getcomputedstyle
+    const declarations = Object.keys(propertiesWithResolvedValueImplemented);
+    forEach.call(declarations, property => {
+      declaration.setProperty(property, getResolvedValue(elt, property));
+    });
+
+    forEach.call(style, property => {
+      declaration.setProperty(property, style.getPropertyValue(property), style.getPropertyPriority(property));
+    });
+
+    return declaration;
+  };
+
+  this.getSelection = function () {
+    return window._document.getSelection();
+  };
+
+  // The captureEvents() and releaseEvents() methods must do nothing
+  this.captureEvents = function () {};
+
+  this.releaseEvents = function () {};
+
+  ///// PUBLIC DATA PROPERTIES (TODO: should be getters)
+
+  function wrapConsoleMethod(method) {
+    return (...args) => {
+      window._virtualConsole.emit(method, ...args);
+    };
+  }
+
+  this.console = {
+    assert: wrapConsoleMethod("assert"),
+    clear: wrapConsoleMethod("clear"),
+    count: wrapConsoleMethod("count"),
+    countReset: wrapConsoleMethod("countReset"),
+    debug: wrapConsoleMethod("debug"),
+    dir: wrapConsoleMethod("dir"),
+    dirxml: wrapConsoleMethod("dirxml"),
+    error: wrapConsoleMethod("error"),
+    group: wrapConsoleMethod("group"),
+    groupCollapsed: wrapConsoleMethod("groupCollapsed"),
+    groupEnd: wrapConsoleMethod("groupEnd"),
+    info: wrapConsoleMethod("info"),
+    log: wrapConsoleMethod("log"),
+    table: wrapConsoleMethod("table"),
+    time: wrapConsoleMethod("time"),
+    timeLog: wrapConsoleMethod("timeLog"),
+    timeEnd: wrapConsoleMethod("timeEnd"),
+    trace: wrapConsoleMethod("trace"),
+    warn: wrapConsoleMethod("warn")
+  };
+
+  function notImplementedMethod(name) {
+    return function () {
+      notImplemented(name, window);
+    };
+  }
+
+  define(this, {
+    name: "",
+    status: "",
+    devicePixelRatio: 1,
+    innerWidth: 1024,
+    innerHeight: 768,
+    outerWidth: 1024,
+    outerHeight: 768,
+    pageXOffset: 0,
+    pageYOffset: 0,
+    screenX: 0,
+    screenLeft: 0,
+    screenY: 0,
+    screenTop: 0,
+    scrollX: 0,
+    scrollY: 0,
+
+    alert: notImplementedMethod("window.alert"),
+    blur: notImplementedMethod("window.blur"),
+    confirm: notImplementedMethod("window.confirm"),
+    focus: notImplementedMethod("window.focus"),
+    moveBy: notImplementedMethod("window.moveBy"),
+    moveTo: notImplementedMethod("window.moveTo"),
+    open: notImplementedMethod("window.open"),
+    print: notImplementedMethod("window.print"),
+    prompt: notImplementedMethod("window.prompt"),
+    resizeBy: notImplementedMethod("window.resizeBy"),
+    resizeTo: notImplementedMethod("window.resizeTo"),
+    scroll: notImplementedMethod("window.scroll"),
+    scrollBy: notImplementedMethod("window.scrollBy"),
+    scrollTo: notImplementedMethod("window.scrollTo")
+  });
+
+  ///// INITIALIZATION
+
+  process.nextTick(() => {
+    if (!window.document) {
+      return; // window might've been closed already
+    }
+
+    if (window.document.readyState === "complete") {
+      fireAnEvent("load", window, undefined, {}, window.document);
+    } else {
+      window.document.addEventListener("load", () => {
+        fireAnEvent("load", window, undefined, {}, window.document);
+
+        if (!idlUtils.implForWrapper(window._document)._pageShowingFlag) {
+          idlUtils.implForWrapper(window._document)._pageShowingFlag = true;
+          fireAnEvent("pageshow", window, PageTransitionEvent, { persisted: false }, window.document);
+        }
+      });
+    }
+  });
+}
+
+function contextifyWindow(window) {
+  if (vm.isContext(window)) {
+    return;
+  }
+
+  vm.createContext(window);
+}
diff --git a/lib/jsdom/browser/default-stylesheet.js b/lib/jsdom/browser/default-stylesheet.js
new file mode 100644
index 0000000..94ce699
--- /dev/null
+++ b/lib/jsdom/browser/default-stylesheet.js
@@ -0,0 +1,785 @@
+// Ideally, we would use
+// https://html.spec.whatwg.org/multipage/rendering.html#the-css-user-agent-style-sheet-and-presentational-hints
+// but for now, just use the version from blink. This file is copied from
+// https://chromium.googlesource.com/chromium/blink/+/96aa3a280ab7d67178c8f122a04949ce5f8579e0/Source/core/css/html.css
+// (removed a line which had octal literals inside since octal literals are not allowed in template strings)
+
+// We use a .js file because otherwise we can't browserify this. (brfs is unusable due to lack of ES2015 support)
+
+module.exports = `
+/*
+ * The default style sheet used to render HTML.
+ *
+ * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+@namespace "http://www.w3.org/1999/xhtml";
+
+html {
+    display: block
+}
+
+:root {
+    scroll-blocks-on: start-touch wheel-event
+}
+
+/* children of the <head> element all have display:none */
+head {
+    display: none
+}
+
+meta {
+    display: none
+}
+
+title {
+    display: none
+}
+
+link {
+    display: none
+}
+
+style {
+    display: none
+}
+
+script {
+    display: none
+}
+
+/* generic block-level elements */
+
+body {
+    display: block;
+    margin: 8px
+}
+
+p {
+    display: block;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1__qem;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+}
+
+div {
+    display: block
+}
+
+layer {
+    display: block
+}
+
+article, aside, footer, header, hgroup, main, nav, section {
+    display: block
+}
+
+marquee {
+    display: inline-block;
+}
+
+address {
+    display: block
+}
+
+blockquote {
+    display: block;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1em;
+    -webkit-margin-start: 40px;
+    -webkit-margin-end: 40px;
+}
+
+figcaption {
+    display: block
+}
+
+figure {
+    display: block;
+    -webkit-margin-before: 1em;
+    -webkit-margin-after: 1em;
+    -webkit-margin-start: 40px;
+    -webkit-margin-end: 40px;
+}
+
+q {
+    display: inline
+}
+
+/* nwmatcher does not support ::before and ::after, so we can't render q
+correctly: https://html.spec.whatwg.org/multipage/rendering.html#phrasing-content-3
+TODO: add q::before and q::after selectors
+*/
+
+center {
+    display: block;
+    /* special centering to be able to emulate the html4/netscape behaviour */
+    text-align: -webkit-center
+}
+
+hr {
+    display: block;
+    -webkit-margin-before: 0.5em;
+    -webkit-margin-after: 0.5em;
+    -webkit-margin-start: auto;
+    -webkit-margin-end: auto;
+    border-style: inset;
+    border-width: 1px;
+    box-sizing: border-box
+}
+
+map {
+    display: inline
+}
+
+video {
+    object-fit: contain;
+}
+
+/* heading elements */
+
+h1 {
+    display: block;
+    font-size: 2em;
+    -webkit-margin-before: 0.67__qem;
+    -webkit-margin-after: 0.67em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    font-weight: bold
+}
+
+article h1,
+aside h1,
+nav h1,
+section h1 {
+    font-size: 1.5em;
+    -webkit-margin-before: 0.83__qem;
+    -webkit-margin-after: 0.83em;
+}
+
+article article h1,
+article aside h1,
+article nav h1,
+article section h1,
+aside article h1,
+aside aside h1,
+aside nav h1,
+aside section h1,
+nav article h1,
+nav aside h1,
+nav nav h1,
+nav section h1,
+section article h1,
+section aside h1,
+section nav h1,
+section section h1 {
+    font-size: 1.17em;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1em;
+}
+
+/* Remaining selectors are deleted because nwmatcher does not support
+:matches() and expanding the selectors manually would be far too verbose.
+Also see https://html.spec.whatwg.org/multipage/rendering.html#sections-and-headings
+TODO: rewrite to use :matches() when nwmatcher supports it.
+*/
+
+h2 {
+    display: block;
+    font-size: 1.5em;
+    -webkit-margin-before: 0.83__qem;
+    -webkit-margin-after: 0.83em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    font-weight: bold
+}
+
+h3 {
+    display: block;
+    font-size: 1.17em;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    font-weight: bold
+}
+
+h4 {
+    display: block;
+    -webkit-margin-before: 1.33__qem;
+    -webkit-margin-after: 1.33em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    font-weight: bold
+}
+
+h5 {
+    display: block;
+    font-size: .83em;
+    -webkit-margin-before: 1.67__qem;
+    -webkit-margin-after: 1.67em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    font-weight: bold
+}
+
+h6 {
+    display: block;
+    font-size: .67em;
+    -webkit-margin-before: 2.33__qem;
+    -webkit-margin-after: 2.33em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    font-weight: bold
+}
+
+/* tables */
+
+table {
+    display: table;
+    border-collapse: separate;
+    border-spacing: 2px;
+    border-color: gray
+}
+
+thead {
+    display: table-header-group;
+    vertical-align: middle;
+    border-color: inherit
+}
+
+tbody {
+    display: table-row-group;
+    vertical-align: middle;
+    border-color: inherit
+}
+
+tfoot {
+    display: table-footer-group;
+    vertical-align: middle;
+    border-color: inherit
+}
+
+/* for tables without table section elements (can happen with XHTML or dynamically created tables) */
+table > tr {
+    vertical-align: middle;
+}
+
+col {
+    display: table-column
+}
+
+colgroup {
+    display: table-column-group
+}
+
+tr {
+    display: table-row;
+    vertical-align: inherit;
+    border-color: inherit
+}
+
+td, th {
+    display: table-cell;
+    vertical-align: inherit
+}
+
+th {
+    font-weight: bold
+}
+
+caption {
+    display: table-caption;
+    text-align: -webkit-center
+}
+
+/* lists */
+
+ul, menu, dir {
+    display: block;
+    list-style-type: disc;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    -webkit-padding-start: 40px
+}
+
+ol {
+    display: block;
+    list-style-type: decimal;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+    -webkit-padding-start: 40px
+}
+
+li {
+    display: list-item;
+    text-align: -webkit-match-parent;
+}
+
+ul ul, ol ul {
+    list-style-type: circle
+}
+
+ol ol ul, ol ul ul, ul ol ul, ul ul ul {
+    list-style-type: square
+}
+
+dd {
+    display: block;
+    -webkit-margin-start: 40px
+}
+
+dl {
+    display: block;
+    -webkit-margin-before: 1__qem;
+    -webkit-margin-after: 1em;
+    -webkit-margin-start: 0;
+    -webkit-margin-end: 0;
+}
+
+dt {
+    display: block
+}
+
+ol ul, ul ol, ul ul, ol ol {
+    -webkit-margin-before: 0;
+    -webkit-margin-after: 0
+}
+
+/* form elements */
+
+form {
+    display: block;
+    margin-top: 0__qem;
+}
+
+label {
+    cursor: default;
+}
+
+legend {
+    display: block;
+    -webkit-padding-start: 2px;
+    -webkit-padding-end: 2px;
+    border: none
+}
+
+fieldset {
+    display: block;
+    -webkit-margin-start: 2px;
+    -webkit-margin-end: 2px;
+    -webkit-padding-before: 0.35em;
+    -webkit-padding-start: 0.75em;
+    -webkit-padding-end: 0.75em;
+    -webkit-padding-after: 0.625em;
+    border: 2px groove ThreeDFace;
+    min-width: -webkit-min-content;
+}
+
+button {
+    -webkit-appearance: button;
+}
+
+/* Form controls don't go vertical. */
+input, textarea, select, button, meter, progress {
+    -webkit-writing-mode: horizontal-tb !important;
+}
+
+input, textarea, select, button {
+    margin: 0__qem;
+    font: -webkit-small-control;
+    text-rendering: auto; /* FIXME: Remove when tabs work with optimizeLegibility. */
+    color: initial;
+    letter-spacing: normal;
+    word-spacing: normal;
+    line-height: normal;
+    text-transform: none;
+    text-indent: 0;
+    text-shadow: none;
+    display: inline-block;
+    text-align: start;
+}
+
+/* TODO: Add " i" to attribute matchers to support case-insensitive matching */
+input[type="hidden"] {
+    display: none
+}
+
+input {
+    -webkit-appearance: textfield;
+    padding: 1px;
+    background-color: white;
+    border: 2px inset;
+    -webkit-rtl-ordering: logical;
+    -webkit-user-select: text;
+    cursor: auto;
+}
+
+input[type="search"] {
+    -webkit-appearance: searchfield;
+    box-sizing: border-box;
+}
+
+select {
+    border-radius: 5px;
+}
+
+textarea {
+    -webkit-appearance: textarea;
+    background-color: white;
+    border: 1px solid;
+    -webkit-rtl-ordering: logical;
+    -webkit-user-select: text;
+    flex-direction: column;
+    resize: auto;
+    cursor: auto;
+    padding: 2px;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+}
+
+input[type="password"] {
+    -webkit-text-security: disc !important;
+}
+
+input[type="hidden"], input[type="image"], input[type="file"] {
+    -webkit-appearance: initial;
+    padding: initial;
+    background-color: initial;
+    border: initial;
+}
+
+input[type="file"] {
+    align-items: baseline;
+    color: inherit;
+    text-align: start !important;
+}
+
+input[type="radio"], input[type="checkbox"] {
+    margin: 3px 0.5ex;
+    padding: initial;
+    background-color: initial;
+    border: initial;
+}
+
+input[type="button"], input[type="submit"], input[type="reset"] {
+    -webkit-appearance: push-button;
+    -webkit-user-select: none;
+    white-space: pre
+}
+
+input[type="button"], input[type="submit"], input[type="reset"], button {
+    align-items: flex-start;
+    text-align: center;
+    cursor: default;
+    color: ButtonText;
+    padding: 2px 6px 3px 6px;
+    border: 2px outset ButtonFace;
+    background-color: ButtonFace;
+    box-sizing: border-box
+}
+
+input[type="range"] {
+    -webkit-appearance: slider-horizontal;
+    padding: initial;
+    border: initial;
+    margin: 2px;
+    color: #909090;
+}
+
+input[type="button"]:disabled, input[type="submit"]:disabled, input[type="reset"]:disabled,
+button:disabled, select:disabled, optgroup:disabled, option:disabled,
+select[disabled]>option {
+    color: GrayText
+}
+
+input[type="button"]:active, input[type="submit"]:active, input[type="reset"]:active, button:active {
+    border-style: inset
+}
+
+input[type="button"]:active:disabled, input[type="submit"]:active:disabled, input[type="reset"]:active:disabled, button:active:disabled {
+    border-style: outset
+}
+
+datalist {
+    display: none
+}
+
+area {
+    display: inline;
+    cursor: pointer;
+}
+
+param {
+    display: none
+}
+
+input[type="checkbox"] {
+    -webkit-appearance: checkbox;
+    box-sizing: border-box;
+}
+
+input[type="radio"] {
+    -webkit-appearance: radio;
+    box-sizing: border-box;
+}
+
+input[type="color"] {
+    -webkit-appearance: square-button;
+    width: 44px;
+    height: 23px;
+    background-color: ButtonFace;
+    /* Same as native_theme_base. */
+    border: 1px #a9a9a9 solid;
+    padding: 1px 2px;
+}
+
+input[type="color"][list] {
+    -webkit-appearance: menulist;
+    width: 88px;
+    height: 23px
+}
+
+select {
+    -webkit-appearance: menulist;
+    box-sizing: border-box;
+    align-items: center;
+    border: 1px solid;
+    white-space: pre;
+    -webkit-rtl-ordering: logical;
+    color: black;
+    background-color: white;
+    cursor: default;
+}
+
+optgroup {
+    font-weight: bolder;
+    display: block;
+}
+
+option {
+    font-weight: normal;
+    display: block;
+    padding: 0 2px 1px 2px;
+    white-space: pre;
+    min-height: 1.2em;
+}
+
+output {
+    display: inline;
+}
+
+/* meter */
+
+meter {
+    -webkit-appearance: meter;
+    box-sizing: border-box;
+    display: inline-block;
+    height: 1em;
+    width: 5em;
+    vertical-align: -0.2em;
+}
+
+/* progress */
+
+progress {
+    -webkit-appearance: progress-bar;
+    box-sizing: border-box;
+    display: inline-block;
+    height: 1em;
+    width: 10em;
+    vertical-align: -0.2em;
+}
+
+/* inline elements */
+
+u, ins {
+    text-decoration: underline
+}
+
+strong, b {
+    font-weight: bold
+}
+
+i, cite, em, var, address, dfn {
+    font-style: italic
+}
+
+tt, code, kbd, samp {
+    font-family: monospace
+}
+
+pre, xmp, plaintext, listing {
+    display: block;
+    font-family: monospace;
+    white-space: pre;
+    margin: 1__qem 0
+}
+
+mark {
+    background-color: yellow;
+    color: black
+}
+
+big {
+    font-size: larger
+}
+
+small {
+    font-size: smaller
+}
+
+s, strike, del {
+    text-decoration: line-through
+}
+
+sub {
+    vertical-align: sub;
+    font-size: smaller
+}
+
+sup {
+    vertical-align: super;
+    font-size: smaller
+}
+
+nobr {
+    white-space: nowrap
+}
+
+/* states */
+
+:focus {
+    outline: auto 5px -webkit-focus-ring-color
+}
+
+/* Read-only text fields do not show a focus ring but do still receive focus */
+html:focus, body:focus, input[readonly]:focus {
+    outline: none
+}
+
+embed:focus, iframe:focus, object:focus {
+    outline: none
+}
+
+input:focus, textarea:focus, select:focus {
+    outline-offset: -2px
+}
+
+input[type="button"]:focus,
+input[type="checkbox"]:focus,
+input[type="file"]:focus,
+input[type="hidden"]:focus,
+input[type="image"]:focus,
+input[type="radio"]:focus,
+input[type="reset"]:focus,
+input[type="search"]:focus,
+input[type="submit"]:focus {
+    outline-offset: 0
+}
+
+/* HTML5 ruby elements */
+
+ruby, rt {
+    text-indent: 0; /* blocks used for ruby rendering should not trigger this */
+}
+
+rt {
+    line-height: normal;
+    -webkit-text-emphasis: none;
+}
+
+ruby > rt {
+    display: block;
+    font-size: 50%;
+    text-align: start;
+}
+
+ruby > rp {
+    display: none;
+}
+
+/* other elements */
+
+noframes {
+    display: none
+}
+
+frameset, frame {
+    display: block
+}
+
+frameset {
+    border-color: inherit
+}
+
+iframe {
+    border: 2px inset
+}
+
+details {
+    display: block
+}
+
+summary {
+    display: block
+}
+
+template {
+    display: none
+}
+
+bdi, output {
+    unicode-bidi: -webkit-isolate;
+}
+
+bdo {
+    unicode-bidi: bidi-override;
+}
+
+textarea[dir=auto] {
+    unicode-bidi: -webkit-plaintext;
+}
+
+dialog:not([open]) {
+    display: none
+}
+
+dialog {
+    position: absolute;
+    left: 0;
+    right: 0;
+    width: -webkit-fit-content;
+    height: -webkit-fit-content;
+    margin: auto;
+    border: solid;
+    padding: 1em;
+    background: white;
+    color: black
+}
+
+/* noscript is handled internally, as it depends on settings. */
+
+`;
diff --git a/lib/jsdom/browser/js-globals.json b/lib/jsdom/browser/js-globals.json
new file mode 100644
index 0000000..9061343
--- /dev/null
+++ b/lib/jsdom/browser/js-globals.json
@@ -0,0 +1,292 @@
+{
+  "Object": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Function": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Number": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "parseFloat": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "parseInt": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Infinity": {
+    "writable": false,
+    "enumerable": false,
+    "configurable": false
+  },
+  "NaN": {
+    "writable": false,
+    "enumerable": false,
+    "configurable": false
+  },
+  "undefined": {
+    "writable": false,
+    "enumerable": false,
+    "configurable": false
+  },
+  "Boolean": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "String": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Symbol": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Date": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Promise": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "RegExp": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Error": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "EvalError": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "RangeError": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "ReferenceError": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "SyntaxError": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "TypeError": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "URIError": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "globalThis": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "JSON": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Math": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Intl": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "ArrayBuffer": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Uint8Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Int8Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Uint16Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Int16Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Uint32Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Int32Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Float32Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Float64Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Uint8ClampedArray": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "BigUint64Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "BigInt64Array": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "DataView": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Map": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "BigInt": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Set": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "WeakMap": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "WeakSet": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Proxy": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Reflect": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "decodeURI": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "decodeURIComponent": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "encodeURI": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "encodeURIComponent": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "escape": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "unescape": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "eval": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "isFinite": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "isNaN": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "SharedArrayBuffer": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "Atomics": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  },
+  "WebAssembly": {
+    "writable": true,
+    "enumerable": false,
+    "configurable": true
+  }
+}
diff --git a/lib/jsdom/browser/not-implemented.js b/lib/jsdom/browser/not-implemented.js
new file mode 100644
index 0000000..a87cc95
--- /dev/null
+++ b/lib/jsdom/browser/not-implemented.js
@@ -0,0 +1,13 @@
+"use strict";
+
+module.exports = function (nameForErrorMessage, window) {
+  if (!window) {
+    // Do nothing for window-less documents.
+    return;
+  }
+
+  const error = new Error(`Not implemented: ${nameForErrorMessage}`);
+  error.type = "not implemented";
+
+  window._virtualConsole.emit("jsdomError", error);
+};
diff --git a/lib/jsdom/browser/parser/html.js b/lib/jsdom/browser/parser/html.js
new file mode 100644
index 0000000..f6e61fc
--- /dev/null
+++ b/lib/jsdom/browser/parser/html.js
@@ -0,0 +1,222 @@
+"use strict";
+
+const parse5 = require("parse5");
+
+const { createElement } = require("../../living/helpers/create-element");
+
+const DocumentType = require("../../living/generated/DocumentType");
+const DocumentFragment = require("../../living/generated/DocumentFragment");
+const Text = require("../../living/generated/Text");
+const Comment = require("../../living/generated/Comment");
+
+const attributes = require("../../living/attributes");
+const nodeTypes = require("../../living/node-type");
+
+const serializationAdapter = require("../../living/domparsing/parse5-adapter-serialization");
+const {
+  customElementReactionsStack, invokeCEReactions, lookupCEDefinition
+} = require("../../living/helpers/custom-elements");
+
+// Horrible monkey-patch to implement https://github.com/inikulin/parse5/issues/237 and
+// https://github.com/inikulin/parse5/issues/285.
+const OpenElementStack = require("parse5/lib/parser/open-element-stack");
+
+const openElementStackOriginalPush = OpenElementStack.prototype.push;
+OpenElementStack.prototype.push = function (...args) {
+  openElementStackOriginalPush.apply(this, args);
+  this.treeAdapter._currentElement = this.current;
+
+  const after = this.items[this.stackTop];
+  if (after._pushedOnStackOfOpenElements) {
+    after._pushedOnStackOfOpenElements();
+  }
+};
+
+const openElementStackOriginalPop = OpenElementStack.prototype.pop;
+OpenElementStack.prototype.pop = function (...args) {
+  const before = this.items[this.stackTop];
+
+  openElementStackOriginalPop.apply(this, args);
+  this.treeAdapter._currentElement = this.current;
+
+  if (before._poppedOffStackOfOpenElements) {
+    before._poppedOffStackOfOpenElements();
+  }
+};
+
+class JSDOMParse5Adapter {
+  constructor(documentImpl, options = {}) {
+    this._documentImpl = documentImpl;
+    this._globalObject = documentImpl._globalObject;
+    this._fragment = options.fragment || false;
+
+    // Since the createElement hook doesn't provide the parent element, we keep track of this using _currentElement:
+    // https://github.com/inikulin/parse5/issues/285. See above horrible monkey-patch for how this is maintained.
+    this._currentElement = undefined;
+  }
+
+  _ownerDocument() {
+    const { _currentElement } = this;
+
+    // The _currentElement is undefined when parsing elements at the root of the document.
+    if (_currentElement) {
+      return _currentElement.localName === "template" ?
+        _currentElement.content._ownerDocument :
+        _currentElement._ownerDocument;
+    }
+
+    return this._documentImpl;
+  }
+
+  createDocument() {
+    // parse5's model assumes that parse(html) will call into here to create the new Document, then return it. However,
+    // jsdom's model assumes we can create a Window (and through that create an empty Document), do some other setup
+    // stuff, and then parse, stuffing nodes into that Document as we go. So to adapt between these two models, we just
+    // return the already-created Document when asked by parse5 to "create" a Document.
+    return this._documentImpl;
+  }
+
+  createDocumentFragment() {
+    const ownerDocument = this._ownerDocument();
+    return DocumentFragment.createImpl(this._globalObject, [], { ownerDocument });
+  }
+
+  // https://html.spec.whatwg.org/#create-an-element-for-the-token
+  createElement(localName, namespace, attrs) {
+    const ownerDocument = this._ownerDocument();
+
+    const isAttribute = attrs.find(attr => attr.name === "is");
+    const isValue = isAttribute ? isAttribute.value : null;
+
+    const definition = lookupCEDefinition(ownerDocument, namespace, localName);
+
+    let willExecuteScript = false;
+    if (definition !== null && !this._fragment) {
+      willExecuteScript = true;
+    }
+
+    if (willExecuteScript) {
+      ownerDocument._throwOnDynamicMarkupInsertionCounter++;
+      customElementReactionsStack.push([]);
+    }
+
+    const element = createElement(ownerDocument, localName, namespace, null, isValue, willExecuteScript);
+    this.adoptAttributes(element, attrs);
+
+    if (willExecuteScript) {
+      const queue = customElementReactionsStack.pop();
+      invokeCEReactions(queue);
+      ownerDocument._throwOnDynamicMarkupInsertionCounter--;
+    }
+
+    if ("_parserInserted" in element) {
+      element._parserInserted = true;
+    }
+
+    return element;
+  }
+
+  createCommentNode(data) {
+    const ownerDocument = this._ownerDocument();
+    return Comment.createImpl(this._globalObject, [], { data, ownerDocument });
+  }
+
+  appendChild(parentNode, newNode) {
+    parentNode._append(newNode);
+  }
+
+  insertBefore(parentNode, newNode, referenceNode) {
+    parentNode._insert(newNode, referenceNode);
+  }
+
+  setTemplateContent(templateElement, contentFragment) {
+    // This code makes the glue between jsdom and parse5 HTMLTemplateElement parsing:
+    //
+    // * jsdom during the construction of the HTMLTemplateElement (for example when create via
+    //   `document.createElement("template")`), creates a DocumentFragment and set it into _templateContents.
+    // * parse5 when parsing a <template> tag creates an HTMLTemplateElement (`createElement` adapter hook) and also
+    //   create a DocumentFragment (`createDocumentFragment` adapter hook).
+    //
+    // At this point we now have to replace the one created in jsdom with one created by parse5.
+    const { _ownerDocument, _host } = templateElement._templateContents;
+    contentFragment._ownerDocument = _ownerDocument;
+    contentFragment._host = _host;
+
+    templateElement._templateContents = contentFragment;
+  }
+
+  setDocumentType(document, name, publicId, systemId) {
+    const ownerDocument = this._ownerDocument();
+    const documentType = DocumentType.createImpl(this._globalObject, [], { name, publicId, systemId, ownerDocument });
+
+    document._append(documentType);
+  }
+
+  setDocumentMode(document, mode) {
+    // TODO: the rest of jsdom ignores this
+    document._mode = mode;
+  }
+
+  detachNode(node) {
+    node.remove();
+  }
+
+  insertText(parentNode, text) {
+    const { lastChild } = parentNode;
+    if (lastChild && lastChild.nodeType === nodeTypes.TEXT_NODE) {
+      lastChild.data += text;
+    } else {
+      const ownerDocument = this._ownerDocument();
+      const textNode = Text.createImpl(this._globalObject, [], { data: text, ownerDocument });
+      parentNode._append(textNode);
+    }
+  }
+
+  insertTextBefore(parentNode, text, referenceNode) {
+    const { previousSibling } = referenceNode;
+    if (previousSibling && previousSibling.nodeType === nodeTypes.TEXT_NODE) {
+      previousSibling.data += text;
+    } else {
+      const ownerDocument = this._ownerDocument();
+      const textNode = Text.createImpl(this._globalObject, [], { data: text, ownerDocument });
+      parentNode._append(textNode, referenceNode);
+    }
+  }
+
+  adoptAttributes(element, attrs) {
+    for (const attr of attrs) {
+      const prefix = attr.prefix === "" ? null : attr.prefix;
+      attributes.setAttributeValue(element, attr.name, attr.value, prefix, attr.namespace);
+    }
+  }
+}
+
+// Assign shared adapters with serializer.
+Object.assign(JSDOMParse5Adapter.prototype, serializationAdapter);
+
+function parseFragment(markup, contextElement) {
+  const ownerDocument = contextElement.localName === "template" ?
+    contextElement.content._ownerDocument :
+    contextElement._ownerDocument;
+
+  const config = Object.assign({}, ownerDocument._parseOptions, {
+    treeAdapter: new JSDOMParse5Adapter(ownerDocument, {
+      fragment: true
+    })
+  });
+
+  return parse5.parseFragment(contextElement, markup, config);
+}
+
+function parseIntoDocument(markup, ownerDocument) {
+  const config = Object.assign({}, ownerDocument._parseOptions, {
+    treeAdapter: new JSDOMParse5Adapter(ownerDocument)
+  });
+
+  return parse5.parse(markup, config);
+}
+
+module.exports = {
+  parseFragment,
+  parseIntoDocument
+};
diff --git a/lib/jsdom/browser/parser/index.js b/lib/jsdom/browser/parser/index.js
new file mode 100644
index 0000000..e09df95
--- /dev/null
+++ b/lib/jsdom/browser/parser/index.js
@@ -0,0 +1,37 @@
+"use strict";
+
+const xmlParser = require("./xml");
+const htmlParser = require("./html");
+
+// https://w3c.github.io/DOM-Parsing/#dfn-fragment-parsing-algorithm
+function parseFragment(markup, contextElement) {
+  const { _parsingMode } = contextElement._ownerDocument;
+
+  let parseAlgorithm;
+  if (_parsingMode === "html") {
+    parseAlgorithm = htmlParser.parseFragment;
+  } else if (_parsingMode === "xml") {
+    parseAlgorithm = xmlParser.parseFragment;
+  }
+
+  // Note: HTML and XML fragment parsing algorithm already return a document fragments; no need to do steps 3 and 4
+  return parseAlgorithm(markup, contextElement);
+}
+
+function parseIntoDocument(markup, ownerDocument) {
+  const { _parsingMode } = ownerDocument;
+
+  let parseAlgorithm;
+  if (_parsingMode === "html") {
+    parseAlgorithm = htmlParser.parseIntoDocument;
+  } else if (_parsingMode === "xml") {
+    parseAlgorithm = xmlParser.parseIntoDocument;
+  }
+
+  return parseAlgorithm(markup, ownerDocument);
+}
+
+module.exports = {
+  parseFragment,
+  parseIntoDocument
+};
diff --git a/lib/jsdom/browser/parser/xml.js b/lib/jsdom/browser/parser/xml.js
new file mode 100644
index 0000000..76759a0
--- /dev/null
+++ b/lib/jsdom/browser/parser/xml.js
@@ -0,0 +1,205 @@
+"use strict";
+
+const { SaxesParser } = require("saxes");
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const { createElement } = require("../../living/helpers/create-element");
+
+const DocumentFragment = require("../../living/generated/DocumentFragment");
+const DocumentType = require("../../living/generated/DocumentType");
+const CDATASection = require("../../living/generated/CDATASection");
+const Comment = require("../../living/generated/Comment");
+const ProcessingInstruction = require("../../living/generated/ProcessingInstruction");
+const Text = require("../../living/generated/Text");
+
+const attributes = require("../../living/attributes");
+const { HTML_NS } = require("../../living/helpers/namespaces");
+
+const HTML5_DOCTYPE = /<!doctype html>/i;
+const PUBLIC_DOCTYPE = /<!doctype\s+([^\s]+)\s+public\s+"([^"]+)"\s+"([^"]+)"/i;
+const SYSTEM_DOCTYPE = /<!doctype\s+([^\s]+)\s+system\s+"([^"]+)"/i;
+const CUSTOM_NAME_DOCTYPE = /<!doctype\s+([^\s>]+)/i;
+
+function parseDocType(globalObject, ownerDocument, html) {
+  if (HTML5_DOCTYPE.test(html)) {
+    return createDocumentType(globalObject, ownerDocument, "html", "", "");
+  }
+
+  const publicPieces = PUBLIC_DOCTYPE.exec(html);
+  if (publicPieces) {
+    return createDocumentType(globalObject, ownerDocument, publicPieces[1], publicPieces[2], publicPieces[3]);
+  }
+
+  const systemPieces = SYSTEM_DOCTYPE.exec(html);
+  if (systemPieces) {
+    return createDocumentType(globalObject, ownerDocument, systemPieces[1], "", systemPieces[2]);
+  }
+
+  const namePiece = CUSTOM_NAME_DOCTYPE.exec(html)[1] || "html";
+  return createDocumentType(globalObject, ownerDocument, namePiece, "", "");
+}
+
+function createDocumentType(globalObject, ownerDocument, name, publicId, systemId) {
+  return DocumentType.createImpl(globalObject, [], { ownerDocument, name, publicId, systemId });
+}
+
+function isHTMLTemplateElement(element) {
+  return element.tagName === "template" && element.namespaceURI === HTML_NS;
+}
+
+
+function createParser(rootNode, globalObject, saxesOptions) {
+  const parser = new SaxesParser({
+    ...saxesOptions,
+    // Browsers always have namespace support.
+    xmlns: true,
+    // We force the parser to treat all documents (even documents declaring themselves to be XML 1.1 documents) as XML
+    // 1.0 documents. See https://github.com/jsdom/jsdom/issues/2677 for a discussion of the stakes.
+    defaultXMLVersion: "1.0",
+    forceXMLVersion: true
+  });
+  const openStack = [rootNode];
+
+  function getOwnerDocument() {
+    const currentElement = openStack[openStack.length - 1];
+
+    return isHTMLTemplateElement(currentElement) ?
+      currentElement._templateContents._ownerDocument :
+      currentElement._ownerDocument;
+  }
+
+  function appendChild(child) {
+    const parentElement = openStack[openStack.length - 1];
+
+    if (isHTMLTemplateElement(parentElement)) {
+      parentElement._templateContents._insert(child, null);
+    } else {
+      parentElement._insert(child, null);
+    }
+  }
+
+  parser.ontext = saxesOptions.fragment ?
+    // In a fragment, all text events produced by saxes must result in a text
+    // node.
+    data => {
+      const ownerDocument = getOwnerDocument();
+      appendChild(Text.createImpl(globalObject, [], { data, ownerDocument }));
+    } :
+    // When parsing a whole document, we must ignore those text nodes that are
+    // produced outside the root element. Saxes produces events for them,
+    // but DOM trees do not record text outside the root element.
+    data => {
+      if (openStack.length > 1) {
+        const ownerDocument = getOwnerDocument();
+        appendChild(Text.createImpl(globalObject, [], { data, ownerDocument }));
+      }
+    };
+
+  parser.oncdata = data => {
+    const ownerDocument = getOwnerDocument();
+    appendChild(CDATASection.createImpl(globalObject, [], { data, ownerDocument }));
+  };
+
+  parser.onopentag = tag => {
+    const { local: tagLocal, attributes: tagAttributes } = tag;
+
+    const ownerDocument = getOwnerDocument();
+    const tagNamespace = tag.uri === "" ? null : tag.uri;
+    const tagPrefix = tag.prefix === "" ? null : tag.prefix;
+    const isValue = tagAttributes.is === undefined ? null : tagAttributes.is.value;
+
+    const elem = createElement(ownerDocument, tagLocal, tagNamespace, tagPrefix, isValue, true);
+
+    // We mark a script element as "parser-inserted", which prevents it from
+    // being immediately executed.
+    if (tagLocal === "script" && tagNamespace === HTML_NS) {
+      elem._parserInserted = true;
+    }
+
+    for (const key of Object.keys(tagAttributes)) {
+      const { prefix, local, uri, value } = tagAttributes[key];
+      attributes.setAttributeValue(
+        elem, local, value, prefix === "" ? null : prefix,
+        uri === "" ? null : uri
+      );
+    }
+
+    appendChild(elem);
+    openStack.push(elem);
+  };
+
+  parser.onclosetag = () => {
+    const elem = openStack.pop();
+    // Once a script is populated, we can execute it.
+    if (elem.localName === "script" && elem.namespaceURI === HTML_NS) {
+      elem._eval();
+    }
+  };
+
+  parser.oncomment = data => {
+    const ownerDocument = getOwnerDocument();
+    appendChild(Comment.createImpl(globalObject, [], { data, ownerDocument }));
+  };
+
+  parser.onprocessinginstruction = ({ target, body }) => {
+    const ownerDocument = getOwnerDocument();
+    appendChild(ProcessingInstruction.createImpl(globalObject, [], { target, data: body, ownerDocument }));
+  };
+
+  parser.ondoctype = dt => {
+    const ownerDocument = getOwnerDocument();
+    appendChild(parseDocType(globalObject, ownerDocument, `<!doctype ${dt}>`));
+
+    const entityMatcher = /<!ENTITY ([^ ]+) "([^"]+)">/g;
+    let result;
+    while ((result = entityMatcher.exec(dt))) {
+      const [, name, value] = result;
+      if (!(name in parser.ENTITIES)) {
+        parser.ENTITIES[name] = value;
+      }
+    }
+  };
+
+  parser.onerror = err => {
+    throw DOMException.create(globalObject, [err.message, "SyntaxError"]);
+  };
+
+  return parser;
+}
+
+function parseFragment(markup, contextElement) {
+  const { _globalObject, _ownerDocument } = contextElement;
+
+  const fragment = DocumentFragment.createImpl(_globalObject, [], { ownerDocument: _ownerDocument });
+
+  // Only parseFragment needs resolvePrefix per the saxes documentation:
+  // https://github.com/lddubeau/saxes#parsing-xml-fragments
+  const parser = createParser(fragment, _globalObject, {
+    fragment: true,
+    resolvePrefix(prefix) {
+      // saxes wants undefined as the return value if the prefix is not defined, not null.
+      return contextElement.lookupNamespaceURI(prefix) || undefined;
+    }
+  });
+
+  parser.write(markup).close();
+
+  return fragment;
+}
+
+function parseIntoDocument(markup, ownerDocument) {
+  const { _globalObject } = ownerDocument;
+
+  const parser = createParser(ownerDocument, _globalObject, {
+    fileName: ownerDocument.location && ownerDocument.location.href
+  });
+
+  parser.write(markup).close();
+
+  return ownerDocument;
+}
+
+module.exports = {
+  parseFragment,
+  parseIntoDocument
+};
diff --git a/lib/jsdom/browser/resources/async-resource-queue.js b/lib/jsdom/browser/resources/async-resource-queue.js
new file mode 100644
index 0000000..51c7bb7
--- /dev/null
+++ b/lib/jsdom/browser/resources/async-resource-queue.js
@@ -0,0 +1,114 @@
+"use strict";
+
+class QueueItem {
+  constructor(onLoad, onError, dependentItem) {
+    this.onLoad = onLoad;
+    this.onError = onError;
+    this.data = null;
+    this.error = null;
+    this.dependentItem = dependentItem;
+  }
+}
+
+/**
+ * AsyncResourceQueue is the queue in charge of run the async scripts
+ * and notify when they finish.
+ */
+module.exports = class AsyncResourceQueue {
+  constructor() {
+    this.items = new Set();
+    this.dependentItems = new Set();
+  }
+
+  count() {
+    return this.items.size + this.dependentItems.size;
+  }
+
+  _notify() {
+    if (this._listener) {
+      this._listener();
+    }
+  }
+
+  _check(item) {
+    let promise;
+
+    if (item.onError && item.error) {
+      promise = item.onError(item.error);
+    } else if (item.onLoad && item.data) {
+      promise = item.onLoad(item.data);
+    }
+
+    promise
+      .then(() => {
+        this.items.delete(item);
+        this.dependentItems.delete(item);
+
+        if (this.count() === 0) {
+          this._notify();
+        }
+      });
+  }
+
+  setListener(listener) {
+    this._listener = listener;
+  }
+
+  push(request, onLoad, onError, dependentItem) {
+    const q = this;
+
+    const item = new QueueItem(onLoad, onError, dependentItem);
+
+    q.items.add(item);
+
+    return request
+      .then(data => {
+        item.data = data;
+
+        if (dependentItem && !dependentItem.finished) {
+          q.dependentItems.add(item);
+          return q.items.delete(item);
+        }
+
+        if (onLoad) {
+          return q._check(item);
+        }
+
+        q.items.delete(item);
+
+        if (q.count() === 0) {
+          q._notify();
+        }
+
+        return null;
+      })
+      .catch(err => {
+        item.error = err;
+
+        if (dependentItem && !dependentItem.finished) {
+          q.dependentItems.add(item);
+          return q.items.delete(item);
+        }
+
+        if (onError) {
+          return q._check(item);
+        }
+
+        q.items.delete(item);
+
+        if (q.count() === 0) {
+          q._notify();
+        }
+
+        return null;
+      });
+  }
+
+  notifyItem(syncItem) {
+    for (const item of this.dependentItems) {
+      if (item.dependentItem === syncItem) {
+        this._check(item);
+      }
+    }
+  }
+};
diff --git a/lib/jsdom/browser/resources/no-op-resource-loader.js b/lib/jsdom/browser/resources/no-op-resource-loader.js
new file mode 100644
index 0000000..985509c
--- /dev/null
+++ b/lib/jsdom/browser/resources/no-op-resource-loader.js
@@ -0,0 +1,8 @@
+"use strict";
+const ResourceLoader = require("./resource-loader.js");
+
+module.exports = class NoOpResourceLoader extends ResourceLoader {
+  fetch() {
+    return null;
+  }
+};
diff --git a/lib/jsdom/browser/resources/per-document-resource-loader.js b/lib/jsdom/browser/resources/per-document-resource-loader.js
new file mode 100644
index 0000000..8a10613
--- /dev/null
+++ b/lib/jsdom/browser/resources/per-document-resource-loader.js
@@ -0,0 +1,95 @@
+"use strict";
+const idlUtils = require("../../living/generated/utils");
+const { fireAnEvent } = require("../../living/helpers/events");
+
+module.exports = class PerDocumentResourceLoader {
+  constructor(document) {
+    this._document = document;
+    this._defaultEncoding = document._encoding;
+    this._resourceLoader = document._defaultView ? document._defaultView._resourceLoader : null;
+    this._requestManager = document._requestManager;
+    this._queue = document._queue;
+    this._deferQueue = document._deferQueue;
+    this._asyncQueue = document._asyncQueue;
+  }
+
+  fetch(url, { element, onLoad, onError }) {
+    const request = this._resourceLoader.fetch(url, {
+      cookieJar: this._document._cookieJar,
+      element: idlUtils.wrapperForImpl(element),
+      referrer: this._document.URL
+    });
+
+    if (request === null) {
+      return null;
+    }
+
+    this._requestManager.add(request);
+
+    const onErrorWrapped = error => {
+      this._requestManager.remove(request);
+
+      if (onError) {
+        onError(error);
+      }
+
+      fireAnEvent("error", element);
+
+      const err = new Error(`Could not load ${element.localName}: "${url}"`);
+      err.type = "resource loading";
+      err.detail = error;
+
+      this._document._defaultView._virtualConsole.emit("jsdomError", err);
+
+      return Promise.resolve();
+    };
+
+    const onLoadWrapped = data => {
+      this._requestManager.remove(request);
+
+      this._addCookies(url, request.response ? request.response.headers : {});
+
+      try {
+        const result = onLoad ? onLoad(data) : undefined;
+
+        return Promise.resolve(result)
+          .then(() => {
+            fireAnEvent("load", element);
+
+            return Promise.resolve();
+          })
+          .catch(err => {
+            return onErrorWrapped(err);
+          });
+      } catch (err) {
+        return onErrorWrapped(err);
+      }
+    };
+
+    if (element.localName === "script" && element.hasAttributeNS(null, "async")) {
+      this._asyncQueue.push(request, onLoadWrapped, onErrorWrapped, this._queue.getLastScript());
+    } else if (element.localName === "script" && element.hasAttributeNS(null, "defer")) {
+      this._deferQueue.push(request, onLoadWrapped, onErrorWrapped, false, element);
+    } else {
+      this._queue.push(request, onLoadWrapped, onErrorWrapped, false, element);
+    }
+
+    return request;
+  }
+
+  _addCookies(url, headers) {
+    let cookies = headers["set-cookie"];
+
+    if (!cookies) {
+      return;
+    }
+
+    if (!Array.isArray(cookies)) {
+      cookies = [cookies];
+    }
+
+    cookies.forEach(cookie => {
+      this._document._cookieJar.setCookieSync(cookie, url, { http: true, ignoreError: true });
+    });
+  }
+};
diff --git a/lib/jsdom/browser/resources/request-manager.js b/lib/jsdom/browser/resources/request-manager.js
new file mode 100644
index 0000000..dbf6ccb
--- /dev/null
+++ b/lib/jsdom/browser/resources/request-manager.js
@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * Manage all the request and it is able to abort
+ * all pending request.
+ */
+module.exports = class RequestManager {
+  constructor() {
+    this.openedRequests = [];
+  }
+
+  add(req) {
+    this.openedRequests.push(req);
+  }
+
+  remove(req) {
+    const idx = this.openedRequests.indexOf(req);
+    if (idx !== -1) {
+      this.openedRequests.splice(idx, 1);
+    }
+  }
+
+  close() {
+    for (const openedRequest of this.openedRequests) {
+      openedRequest.abort();
+    }
+    this.openedRequests = [];
+  }
+
+  size() {
+    return this.openedRequests.length;
+  }
+};
diff --git a/lib/jsdom/browser/resources/resource-loader.js b/lib/jsdom/browser/resources/resource-loader.js
new file mode 100644
index 0000000..b5cf250
--- /dev/null
+++ b/lib/jsdom/browser/resources/resource-loader.js
@@ -0,0 +1,113 @@
+"use strict";
+const fs = require("fs");
+const { parseURL } = require("whatwg-url");
+const dataURLFromRecord = require("data-urls").fromURLRecord;
+const request = require("request-promise-native");
+const wrapCookieJarForRequest = require("../../living/helpers/wrap-cookie-jar-for-request");
+const packageVersion = require("../../../../package.json").version;
+const IS_BROWSER = Object.prototype.toString.call(process) !== "[object process]";
+
+module.exports = class ResourceLoader {
+  constructor({
+    strictSSL = true,
+    proxy = undefined,
+    userAgent = `Mozilla/5.0 (${process.platform || "unknown OS"}) AppleWebKit/537.36 ` +
+                `(KHTML, like Gecko) jsdom/${packageVersion}`
+  } = {}) {
+    this._strictSSL = strictSSL;
+    this._proxy = proxy;
+    this._userAgent = userAgent;
+  }
+
+  _readFile(filePath) {
+    let readableStream;
+    let abort; // Native Promises doesn't have an "abort" method.
+
+    /*
+     * Creating a promise for two reason:
+     *   1. fetch always return a promise.
+     *   2. We need to add an abort handler.
+    */
+    const promise = new Promise((resolve, reject) => {
+      readableStream = fs.createReadStream(filePath);
+      let data = Buffer.alloc(0);
+
+      abort = reject;
+
+      readableStream.on("error", reject);
+
+      readableStream.on("data", chunk => {
+        data = Buffer.concat([data, chunk]);
+      });
+
+      readableStream.on("end", () => {
+        resolve(data);
+      });
+    });
+
+    promise.abort = () => {
+      readableStream.destroy();
+      const error = new Error("request canceled by user");
+      error.isAbortError = true;
+      abort(error);
+    };
+
+    return promise;
+  }
+
+  _getRequestOptions({ cookieJar, referrer, accept = "*/*" }) {
+    const requestOptions = {
+      encoding: null,
+      gzip: true,
+      jar: wrapCookieJarForRequest(cookieJar),
+      strictSSL: this._strictSSL,
+      proxy: this._proxy,
+      forever: true,
+      headers: {
+        "User-Agent": this._userAgent,
+        "Accept-Language": "en",
+        Accept: accept
+      }
+    };
+
+    if (referrer && !IS_BROWSER) {
+      requestOptions.headers.referer = referrer;
+    }
+
+    return requestOptions;
+  }
+
+  fetch(urlString, options = {}) {
+    const url = parseURL(urlString);
+
+    if (!url) {
+      return Promise.reject(new Error(`Tried to fetch invalid URL ${urlString}`));
+    }
+
+    switch (url.scheme) {
+      case "data": {
+        return Promise.resolve(dataURLFromRecord(url).body);
+      }
+
+      case "http":
+      case "https": {
+        const requestOptions = this._getRequestOptions(options);
+        return request(urlString, requestOptions);
+      }
+
+      case "file": {
+        // TODO: Improve the URL => file algorithm. See https://github.com/jsdom/jsdom/pull/2279#discussion_r199977987
+        const filePath = urlString
+          .replace(/^file:\/\//, "")
+          .replace(/^\/([a-z]):\//i, "$1:/")
+          .replace(/%20/g, " ");
+
+        return this._readFile(filePath);
+      }
+
+      default: {
+        return Promise.reject(new Error(`Tried to fetch URL ${urlString} with invalid scheme ${url.scheme}`));
+      }
+    }
+  }
+};
diff --git a/lib/jsdom/browser/resources/resource-queue.js b/lib/jsdom/browser/resources/resource-queue.js
new file mode 100644
index 0000000..793da2d
--- /dev/null
+++ b/lib/jsdom/browser/resources/resource-queue.js
@@ -0,0 +1,142 @@
+"use strict";
+
+/**
+ * Queue for all the resources to be download except async scripts.
+ * Async scripts have their own queue AsyncResourceQueue.
+ */
+module.exports = class ResourceQueue {
+  constructor({ paused, asyncQueue } = {}) {
+    this.paused = Boolean(paused);
+    this._asyncQueue = asyncQueue;
+  }
+
+  getLastScript() {
+    let head = this.tail;
+
+    while (head) {
+      if (head.isScript) {
+        return head;
+      }
+      head = head.prev;
+    }
+
+    return null;
+  }
+
+  _moreScripts() {
+    let found = false;
+
+    let head = this.tail;
+    while (head && !found) {
+      found = head.isScript;
+      head = head.prev;
+    }
+
+    return found;
+  }
+
+  _notify() {
+    if (this._listener) {
+      this._listener();
+    }
+  }
+
+  setListener(listener) {
+    this._listener = listener;
+  }
+
+  push(request, onLoad, onError, keepLast, element) {
+    const isScript = element ? element.localName === "script" : false;
+
+    if (!request) {
+      if (isScript && !this._moreScripts()) {
+        return onLoad();
+      }
+
+      request = new Promise(resolve => resolve());
+    }
+    const q = this;
+    const item = {
+      isScript,
+      err: null,
+      element,
+      fired: false,
+      data: null,
+      keepLast,
+      prev: q.tail,
+      check() {
+        if (!q.paused && !this.prev && this.fired) {
+          let promise;
+
+          if (this.err && onError) {
+            promise = onError(this.err);
+          }
+
+          if (!this.err && onLoad) {
+            promise = onLoad(this.data);
+          }
+
+          Promise.resolve(promise)
+            .then(() => {
+              if (this.next) {
+                this.next.prev = null;
+                this.next.check();
+              } else { // q.tail===this
+                q.tail = null;
+                q._notify();
+              }
+
+              this.finished = true;
+
+              if (q._asyncQueue) {
+                q._asyncQueue.notifyItem(this);
+              }
+            });
+        }
+      }
+    };
+    if (q.tail) {
+      if (q.tail.keepLast) {
+        // if the tail is the load event in document and we receive a new element to load
+        // we should add this new request before the load event.
+        if (q.tail.prev) {
+          q.tail.prev.next = item;
+        }
+        item.prev = q.tail.prev;
+        q.tail.prev = item;
+        item.next = q.tail;
+      } else {
+        q.tail.next = item;
+        q.tail = item;
+      }
+    } else {
+      q.tail = item;
+    }
+    return request
+      .then(data => {
+        item.fired = 1;
+        item.data = data;
+        item.check();
+      })
+      .catch(err => {
+        item.fired = true;
+        item.err = err;
+        item.check();
+      });
+  }
+
+  resume() {
+    if (!this.paused) {
+      return;
+    }
+    this.paused = false;
+
+    let head = this.tail;
+    while (head && head.prev) {
+      head = head.prev;
+    }
+    if (head) {
+      head.check();
+    }
+  }
+};
diff --git a/lib/jsdom/level2/style.js b/lib/jsdom/level2/style.js
new file mode 100644
index 0000000..94942be
--- /dev/null
+++ b/lib/jsdom/level2/style.js
@@ -0,0 +1,70 @@
+"use strict";
+const cssom = require("cssom");
+const cssstyle = require("cssstyle");
+
+// http://dev.w3.org/csswg/cssom/#stylesheetlist
+// TODO: implement using webidl2js
+function StyleSheetList() {}
+
+Object.setPrototypeOf(StyleSheetList.prototype, Array.prototype);
+
+StyleSheetList.prototype.item = function item(i) {
+  return Object.prototype.hasOwnProperty.call(this, i) ? this[i] : null;
+};
+
+exports.StyleSheetList = StyleSheetList;
+
+exports.addToCore = core => {
+  // What works now:
+  // - Accessing the rules defined in individual stylesheets
+  // - Modifications to style content attribute are reflected in style property
+  // - Modifications to style property are reflected in style content attribute
+  // TODO
+  // - Modifications to style element's textContent are reflected in sheet property.
+  // - Modifications to style element's sheet property are reflected in textContent.
+  // - Modifications to link.href property are reflected in sheet property.
+  // - Less-used features of link: disabled
+  // - Less-used features of style: disabled, scoped, title
+  // - CSSOM-View
+  //   - getComputedStyle(): requires default stylesheet, cascading, inheritance,
+  //     filtering by @media (screen? print?), layout for widths/heights
+  // - Load events are not in the specs, but apparently some browsers
+  //   implement something. Should onload only fire after all @imports have been
+  //   loaded, or only the primary sheet?
+
+  core.StyleSheet = cssom.StyleSheet;
+  core.MediaList = cssom.MediaList;
+  core.CSSStyleSheet = cssom.CSSStyleSheet;
+  core.CSSRule = cssom.CSSRule;
+  core.CSSStyleRule = cssom.CSSStyleRule;
+  core.CSSMediaRule = cssom.CSSMediaRule;
+  core.CSSImportRule = cssom.CSSImportRule;
+  core.CSSStyleDeclaration = cssstyle.CSSStyleDeclaration;
+  core.StyleSheetList = StyleSheetList;
+
+  // Relavant specs
+  // http://www.w3.org/TR/DOM-Level-2-Style (2000)
+  // http://www.w3.org/TR/cssom-view/ (2008)
+  // http://dev.w3.org/csswg/cssom/ (2010) Meant to replace DOM Level 2 Style
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/ HTML5, of course
+  // http://dev.w3.org/csswg/css-style-attr/  not sure what's new here
+
+  // Objects that aren't in cssom library but should be:
+  //   CSSRuleList  (cssom just uses array)
+  //   CSSFontFaceRule
+  //   CSSPageRule
+
+  // These rules don't really make sense to implement, so CSSOM draft makes them
+  // obsolete.
+  //   CSSCharsetRule
+  //   CSSUnknownRule
+
+  // These objects are considered obsolete by CSSOM draft, although modern
+  // browsers implement them.
+  //   CSSValue
+  //   CSSPrimitiveValue
+  //   CSSValueList
+  //   RGBColor
+  //   Rect
+  //   Counter
+};
diff --git a/lib/jsdom/level3/xpath.js b/lib/jsdom/level3/xpath.js
new file mode 100644
index 0000000..28648c4
--- /dev/null
+++ b/lib/jsdom/level3/xpath.js
@@ -0,0 +1,1874 @@
+/** Here is yet another implementation of XPath 1.0 in Javascript.
+ *
+ * My goal was to make it relatively compact, but as I fixed all the axis bugs
+ * the axes became more and more complicated. :-(.
+ *
+ * I have not implemented namespaces or case-sensitive axes for XML yet.
+ *
+ * How to test it in Chrome: You can make a Chrome extension that replaces
+ * the WebKit XPath parser with this one. But it takes a bit of effort to
+ * get around isolated world and same-origin restrictions:
+ * manifest.json:
+    {
+      "name": "XPathTest",
+      "version": "0.1",
+      "content_scripts": [{
+        "matches": ["http://localhost/*"],  // or wildcard host
+        "js": ["xpath.js", "injection.js"],
+        "all_frames": true, "run_at": "document_start"
+      }]
+    }
+ * injection.js:
+    // goal: give my xpath object to the website's JS context.
+    var script = document.createElement('script');
+    script.textContent =
+        "document.addEventListener('xpathextend', function(e) {\n" +
+        "  console.log('extending document with xpath...');\n" +
+        "  e.detail(window);" +
+        "});";
+    document.documentElement.appendChild(script);
+    document.documentElement.removeChild(script);
+    var evt = document.createEvent('CustomEvent');
+    evt.initCustomEvent('xpathextend', true, true, this.xpath.extend);
+    document.dispatchEvent(evt);
+ */
+module.exports = core => {
+  var xpath = {};
+
+  // Helper function to deal with the migration of Attr to no longer have a nodeName property despite this codebase
+  // assuming it does.
+  function getNodeName(nodeOrAttr) {
+    return nodeOrAttr.constructor.name === 'Attr' ? nodeOrAttr.name : nodeOrAttr.nodeName;
+  }
+
+  /***************************************************************************
+   *                            Tokenization                                 *
+   ***************************************************************************/
+  /**
+   * The XPath lexer is basically a single regular expression, along with
+   * some helper functions to pop different types.
+   */
+  var Stream = xpath.Stream = function Stream(str) {
+    this.original = this.str = str;
+    this.peeked = null;
+    // TODO: not really needed, but supposedly tokenizer also disambiguates
+    // a * b vs. node test *
+    this.prev = null;  // for debugging
+    this.prevprev = null;
+  }
+  Stream.prototype = {
+    peek: function() {
+      if (this.peeked) return this.peeked;
+      var m = this.re.exec(this.str);
+      if (!m) return null;
+      this.str = this.str.substr(m[0].length);
+      return this.peeked = m[1];
+    },
+    /** Peek 2 tokens ahead. */
+    peek2: function() {
+      this.peek();  // make sure this.peeked is set
+      var m = this.re.exec(this.str);
+      if (!m) return null;
+      return m[1];
+    },
+    pop: function() {
+      var r = this.peek();
+      this.peeked = null;
+      this.prevprev = this.prev;
+      this.prev = r;
+      return r;
+    },
+    trypop: function(tokens) {
+      var tok = this.peek();
+      if (tok === tokens) return this.pop();
+      if (Array.isArray(tokens)) {
+        for (var i = 0; i < tokens.length; ++i) {
+          var t = tokens[i];
+          if (t == tok) return this.pop();;
+        }
+      }
+    },
+    trypopfuncname: function() {
+      var tok = this.peek();
+      if (!this.isQnameRe.test(tok))
+        return null;
+      switch (tok) {
+        case 'comment': case 'text': case 'processing-instruction': case 'node':
+          return null;
+      }
+      if ('(' != this.peek2()) return null;
+      return this.pop();
+    },
+    trypopaxisname: function() {
+      var tok = this.peek();
+      switch (tok) {
+        case 'ancestor': case 'ancestor-or-self': case 'attribute':
+        case 'child': case 'descendant': case 'descendant-or-self':
+        case 'following': case 'following-sibling': case 'namespace':
+        case 'parent': case 'preceding': case 'preceding-sibling': case 'self':
+          if ('::' == this.peek2()) return this.pop();
+      }
+      return null;
+    },
+    trypopnametest: function() {
+      var tok = this.peek();
+      if ('*' === tok || this.startsWithNcNameRe.test(tok)) return this.pop();
+      return null;
+    },
+    trypopliteral: function() {
+      var tok = this.peek();
+      if (null == tok) return null;
+      var first = tok.charAt(0);
+      var last = tok.charAt(tok.length - 1);
+      if ('"' === first && '"' === last ||
+          "'" === first && "'" === last) {
+        this.pop();
+        return tok.substr(1, tok.length - 2);
+      }
+    },
+    trypopnumber: function() {
+      var tok = this.peek();
+      if (this.isNumberRe.test(tok)) return parseFloat(this.pop());
+      else return null;
+    },
+    trypopvarref: function() {
+      var tok = this.peek();
+      if (null == tok) return null;
+      if ('$' === tok.charAt(0)) return this.pop().substr(1);
+      else return null;
+    },
+    position: function() {
+      return this.original.length - this.str.length;
+    }
+  };
+  (function() {
+    // http://www.w3.org/TR/REC-xml-names/#NT-NCName
+    var nameStartCharsExceptColon =
+        'A-Z_a-z\xc0-\xd6\xd8-\xf6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF' +
+        '\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF' +
+        '\uFDF0-\uFFFD';  // JS doesn't support [#x10000-#xEFFFF]
+    var nameCharExceptColon = nameStartCharsExceptColon +
+        '\\-\\.0-9\xb7\u0300-\u036F\u203F-\u2040';
+    var ncNameChars = '[' + nameStartCharsExceptColon +
+        '][' + nameCharExceptColon + ']*'
+    // http://www.w3.org/TR/REC-xml-names/#NT-QName
+    var qNameChars = ncNameChars + '(?::' + ncNameChars + ')?';
+    var otherChars = '\\.\\.|[\\(\\)\\[\\].@,]|::';  // .. must come before [.]
+    var operatorChars =
+        'and|or|mod|div|' +
+        '//|!=|<=|>=|[*/|+\\-=<>]';  // //, !=, <=, >= before individual ones.
+    var literal = '"[^"]*"|' + "'[^']*'";
+    var numberChars = '[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+';
+    var variableReference = '\\$' + qNameChars;
+    var nameTestChars = '\\*|' + ncNameChars + ':\\*|' + qNameChars;
+    var optionalSpace = '[ \t\r\n]*';  // stricter than regexp \s.
+    var nodeType = 'comment|text|processing-instruction|node';
+    var re = new RegExp(
+        // numberChars before otherChars so that leading-decimal doesn't become .
+        '^' + optionalSpace + '(' + numberChars + '|' + otherChars + '|' +
+        nameTestChars + '|' + operatorChars + '|' + literal + '|' +
+        variableReference + ')'
+        // operatorName | nodeType | functionName | axisName are lumped into
+        // qName for now; we'll check them on pop.
+    );
+    Stream.prototype.re = re;
+    Stream.prototype.startsWithNcNameRe = new RegExp('^' + ncNameChars);
+    Stream.prototype.isQnameRe = new RegExp('^' + qNameChars + '$');
+    Stream.prototype.isNumberRe = new RegExp('^' + numberChars + '$');
+  })();
+
+  /***************************************************************************
+   *                               Parsing                                   *
+   ***************************************************************************/
+  var parse = xpath.parse = function parse(stream, a) {
+    var r = orExpr(stream,a);
+    var x, unparsed = [];
+    while (x = stream.pop()) {
+      unparsed.push(x);
+    }
+    if (unparsed.length)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Unparsed tokens: ' + unparsed.join(' '));
+    return r;
+  }
+
+  /**
+   * binaryL  ::= subExpr
+   *            | binaryL op subExpr
+   * so a op b op c becomes ((a op b) op c)
+   */
+  function binaryL(subExpr, stream, a, ops) {
+    var lhs = subExpr(stream, a);
+    if (lhs == null) return null;
+    var op;
+    while (op = stream.trypop(ops)) {
+      var rhs = subExpr(stream, a);
+      if (rhs == null)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected something after ' + op);
+      lhs = a.node(op, lhs, rhs);
+    }
+    return lhs;
+  }
+  /**
+   * Too bad this is never used. If they made a ** operator (raise to power),
+   ( we would use it.
+   * binaryR  ::= subExpr
+   *            | subExpr op binaryR
+   * so a op b op c becomes (a op (b op c))
+   */
+  function binaryR(subExpr, stream, a, ops) {
+    var lhs = subExpr(stream, a);
+    if (lhs == null) return null;
+    var op = stream.trypop(ops);
+    if (op) {
+      var rhs = binaryR(stream, a);
+      if (rhs == null)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected something after ' + op);
+      return a.node(op, lhs, rhs);
+    } else {
+      return lhs;// TODO
+    }
+  }
+  /** [1] LocationPath::= RelativeLocationPath | AbsoluteLocationPath
+   * e.g. a, a/b, //a/b
+   */
+  function locationPath(stream, a) {
+    return absoluteLocationPath(stream, a) ||
+           relativeLocationPath(null, stream, a);
+  }
+  /** [2] AbsoluteLocationPath::= '/' RelativeLocationPath? | AbbreviatedAbsoluteLocationPath
+   *  [10] AbbreviatedAbsoluteLocationPath::= '//' RelativeLocationPath
+   */
+  function absoluteLocationPath(stream, a) {
+    var op = stream.peek();
+    if ('/' === op || '//' === op) {
+      var lhs = a.node('Root');
+      return relativeLocationPath(lhs, stream, a, true);
+    } else {
+      return null;
+    }
+  }
+  /** [3] RelativeLocationPath::= Step | RelativeLocationPath '/' Step |
+   *                            | AbbreviatedRelativeLocationPath
+   *  [11] AbbreviatedRelativeLocationPath::= RelativeLocationPath '//' Step
+   * e.g. p/a, etc.
+   */
+  function relativeLocationPath(lhs, stream, a, isOnlyRootOk) {
+    if (null == lhs) {
+      lhs = step(stream, a);
+      if (null == lhs) return lhs;
+    }
+    var op;
+    while (op = stream.trypop(['/', '//'])) {
+      if ('//' === op) {
+        lhs = a.node('/', lhs,
+                     a.node('Axis', 'descendant-or-self', 'node', undefined));
+      }
+      var rhs = step(stream, a);
+      if (null == rhs && '/' === op && isOnlyRootOk) return lhs;
+      else isOnlyRootOk = false;
+      if (null == rhs)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected step after ' + op);
+      lhs = a.node('/', lhs, rhs);
+    }
+    return lhs;
+  }
+  /** [4] Step::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+   *  [12] AbbreviatedStep::= '.' | '..'
+   * e.g. @href, self::p, p, a[@href], ., ..
+   */
+  function step(stream, a) {
+    var abbrStep = stream.trypop(['.', '..']);
+    if ('.' === abbrStep)  // A location step of . is short for self::node().
+      return a.node('Axis', 'self', 'node');
+    if ('..' === abbrStep)  // A location step of .. is short for parent::node()
+      return a.node('Axis', 'parent', 'node');
+
+    var axis = axisSpecifier(stream, a);
+    var nodeType = nodeTypeTest(stream, a);
+    var nodeName;
+    if (null == nodeType) nodeName = nodeNameTest(stream, a);
+    if (null == axis && null == nodeType && null == nodeName) return null;
+    if (null == nodeType && null == nodeName)
+        throw new XPathException(
+            XPathException.INVALID_EXPRESSION_ERR,
+            'Position ' + stream.position() +
+            ': Expected nodeTest after axisSpecifier ' + axis);
+    if (null == axis) axis = 'child';
+    if (null == nodeType) {
+      // When there's only a node name, then the node type is forced to be the
+      // principal node type of the axis.
+      // see http://www.w3.org/TR/xpath/#dt-principal-node-type
+      if ('attribute' === axis) nodeType = 'attribute';
+      else if ('namespace' === axis) nodeType = 'namespace';
+      else nodeType = 'element';
+    }
+    var lhs = a.node('Axis', axis, nodeType, nodeName);
+    var pred;
+    while (null != (pred = predicate(lhs, stream, a))) {
+      lhs = pred;
+    }
+    return lhs;
+  }
+  /** [5] AxisSpecifier::= AxisName '::' | AbbreviatedAxisSpecifier
+   *  [6] AxisName::= 'ancestor' | 'ancestor-or-self' | 'attribute' | 'child'
+   *                | 'descendant' | 'descendant-or-self' | 'following'
+   *                | 'following-sibling' | 'namespace' | 'parent' |
+   *                | 'preceding' | 'preceding-sibling' | 'self'
+   *  [13] AbbreviatedAxisSpecifier::= '@'?
+   */
+  function axisSpecifier(stream, a) {
+    var attr = stream.trypop('@');
+    if (null != attr) return 'attribute';
+    var axisName = stream.trypopaxisname();
+    if (null != axisName) {
+      var coloncolon = stream.trypop('::');
+      if (null == coloncolon)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Should not happen. Should be ::.');
+      return axisName;
+    }
+  }
+  /** [7] NodeTest::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+   *  [38] NodeType::= 'comment' | 'text' | 'processing-instruction' | 'node'
+   * I've split nodeTypeTest from nodeNameTest for convenience.
+   */
+  function nodeTypeTest(stream, a) {
+    if ('(' !== stream.peek2()) {
+      return null;
+    }
+    var type = stream.trypop(['comment', 'text', 'processing-instruction', 'node']);
+    if (null != type) {
+      if (null == stream.trypop('('))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Should not happen.');
+      var param = undefined;
+      if (type == 'processing-instruction') {
+        param = stream.trypopliteral();
+      }
+      if (null == stream.trypop(')'))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected close parens.');
+      return type
+    }
+  }
+  function nodeNameTest(stream, a) {
+    var name = stream.trypopnametest();
+    if (name != null) return name;
+    else return null;
+  }
+  /** [8] Predicate::= '[' PredicateExpr ']'
+   *  [9] PredicateExpr::= Expr
+   */
+  function predicate(lhs, stream, a) {
+    if (null == stream.trypop('[')) return null;
+    var expr = orExpr(stream, a);
+    if (null == expr)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Expected expression after [');
+    if (null == stream.trypop(']'))
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Expected ] after expression.');
+    return a.node('Predicate', lhs, expr);
+  }
+  /** [14] Expr::= OrExpr
+   */
+  /** [15] PrimaryExpr::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+   * e.g. $x,  (3+4),  "hi",  32,  f(x)
+   */
+  function primaryExpr(stream, a) {
+    var x = stream.trypopliteral();
+    if (null == x)
+      x = stream.trypopnumber();
+    if (null != x) {
+      return x;
+    }
+    var varRef = stream.trypopvarref();
+    if (null != varRef) return a.node('VariableReference', varRef);
+    var funCall = functionCall(stream, a);
+    if (null != funCall) {
+      return funCall;
+    }
+    if (stream.trypop('(')) {
+      var e = orExpr(stream, a);
+      if (null == e)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected expression after (.');
+      if (null == stream.trypop(')'))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected ) after expression.');
+      return e;
+    }
+    return null;
+  }
+  /** [16] FunctionCall::= FunctionName '(' ( Argument ( ',' Argument )* )? ')'
+   *  [17] Argument::= Expr
+   */
+  function functionCall(stream, a) {
+    var name = stream.trypopfuncname(stream, a);
+    if (null == name) return null;
+    if (null == stream.trypop('('))
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Position ' + stream.position() +
+                               ': Expected ( ) after function name.');
+    var params = [];
+    var first = true;
+    while (null == stream.trypop(')')) {
+      if (!first && null == stream.trypop(','))
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected , between arguments of the function.');
+      first = false;
+      var param = orExpr(stream, a);
+      if (param == null)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected expression as argument of function.');
+      params.push(param);
+    }
+    return a.node('FunctionCall', name, params);
+  }
+
+  /** [18] UnionExpr::= PathExpr | UnionExpr '|' PathExpr
+   */
+  function unionExpr(stream, a) { return binaryL(pathExpr, stream, a, '|'); }
+  /** [19] PathExpr ::= LocationPath
+   *                  | FilterExpr
+   *                  | FilterExpr '/' RelativeLocationPath
+   *                  | FilterExpr '//' RelativeLocationPath
+   * Unlike most other nodes, this one always generates a node because
+   * at this point all reverse nodesets must turn into a forward nodeset
+   */
+  function pathExpr(stream, a) {
+    // We have to do FilterExpr before LocationPath because otherwise
+    // LocationPath will eat up the name from a function call.
+    var filter = filterExpr(stream, a);
+    if (null == filter) {
+      var loc = locationPath(stream, a);
+      if (null == loc) {
+        throw new Error
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': The expression shouldn\'t be empty...');
+      }
+      return a.node('PathExpr', loc);
+    }
+    var rel = relativeLocationPath(filter, stream, a, false);
+    if (filter === rel) return rel;
+    else return a.node('PathExpr', rel);
+  }
+  /** [20] FilterExpr::= PrimaryExpr | FilterExpr Predicate
+   * aka. FilterExpr ::= PrimaryExpr Predicate*
+   */
+  function filterExpr(stream, a) {
+    var primary = primaryExpr(stream, a);
+    if (primary == null) return null;
+    var pred, lhs = primary;
+    while (null != (pred = predicate(lhs, stream, a))) {
+      lhs = pred;
+    }
+    return lhs;
+  }
+
+  /** [21] OrExpr::= AndExpr | OrExpr 'or' AndExpr
+   */
+  function orExpr(stream, a) {
+    var orig = (stream.peeked || '') + stream.str
+    var r = binaryL(andExpr, stream, a, 'or');
+    var now = (stream.peeked || '') + stream.str;
+    return r;
+  }
+  /** [22] AndExpr::= EqualityExpr | AndExpr 'and' EqualityExpr
+   */
+  function andExpr(stream, a) { return binaryL(equalityExpr, stream, a, 'and'); }
+  /** [23] EqualityExpr::= RelationalExpr | EqualityExpr '=' RelationalExpr
+   *                     | EqualityExpr '!=' RelationalExpr
+   */
+  function equalityExpr(stream, a) { return binaryL(relationalExpr, stream, a, ['=','!=']); }
+  /** [24] RelationalExpr::= AdditiveExpr | RelationalExpr '<' AdditiveExpr
+   *                       | RelationalExpr '>' AdditiveExpr
+   *                       | RelationalExpr '<=' AdditiveExpr
+   *                       | RelationalExpr '>=' AdditiveExpr
+   */
+  function relationalExpr(stream, a) { return binaryL(additiveExpr, stream, a, ['<','>','<=','>=']); }
+  /** [25] AdditiveExpr::= MultiplicativeExpr
+   *                     | AdditiveExpr '+' MultiplicativeExpr
+   *                     | AdditiveExpr '-' MultiplicativeExpr
+   */
+  function additiveExpr(stream, a) { return binaryL(multiplicativeExpr, stream, a, ['+','-']); }
+  /** [26] MultiplicativeExpr::= UnaryExpr
+   *                           | MultiplicativeExpr MultiplyOperator UnaryExpr
+   *                           | MultiplicativeExpr 'div' UnaryExpr
+   *                           | MultiplicativeExpr 'mod' UnaryExpr
+   */
+  function multiplicativeExpr(stream, a) { return binaryL(unaryExpr, stream, a, ['*','div','mod']); }
+  /** [27] UnaryExpr::= UnionExpr | '-' UnaryExpr
+   */
+  function unaryExpr(stream, a) {
+    if (stream.trypop('-')) {
+      var e = unaryExpr(stream, a);
+      if (null == e)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Expected unary expression after -');
+      return a.node('UnaryMinus', e);
+    }
+    else return unionExpr(stream, a);
+  }
+  var astFactory = {
+    node: function() {return Array.prototype.slice.call(arguments);}
+  };
+
+
+  /***************************************************************************
+   *                            Optimizations (TODO)                         *
+   ***************************************************************************/
+  /**
+   * Some things I've been considering:
+   * 1) a//b becomes a/descendant::b if there's no predicate that uses
+   *    position() or last()
+   * 2) axis[pred]: when pred doesn't use position, evaluate it just once per
+   *    node in the node-set rather than once per (node, position, last).
+   * For more optimizations, look up Gecko's optimizer:
+   * http://mxr.mozilla.org/mozilla-central/source/content/xslt/src/xpath/txXPathOptimizer.cpp
+   */
+  // TODO
+  function optimize(ast) {
+  }
+
+  /***************************************************************************
+   *                           Evaluation: axes                              *
+   ***************************************************************************/
+
+  /**
+   * Data types: For string, number, boolean, we just use Javascript types.
+   * Node-sets have the form
+   *    {nodes: [node, ...]}
+   * or {nodes: [node, ...], pos: [[1], [2], ...], lasts: [[1], [2], ...]}
+   *
+   * Most of the time, only the node is used and the position information is
+   * discarded. But if you use a predicate, we need to try every value of
+   * position and last in case the predicate calls position() or last().
+   */
+
+  /**
+   * The NodeMultiSet is a helper class to help generate
+   * {nodes:[], pos:[], lasts:[]} structures. It is useful for the
+   * descendant, descendant-or-self, following-sibling, and
+   * preceding-sibling axes for which we can use a stack to organize things.
+   */
+  function NodeMultiSet(isReverseAxis) {
+    this.nodes = [];
+    this.pos = [];
+    this.lasts = [];
+    this.nextPos = [];
+    this.seriesIndexes = [];  // index within nodes that each series begins.
+    this.isReverseAxis = isReverseAxis;
+    this._pushToNodes = isReverseAxis ? Array.prototype.unshift : Array.prototype.push;
+  }
+  NodeMultiSet.prototype = {
+    pushSeries: function pushSeries() {
+      this.nextPos.push(1);
+      this.seriesIndexes.push(this.nodes.length);
+    },
+    popSeries: function popSeries() {
+      console.assert(0 < this.nextPos.length, this.nextPos);
+      var last = this.nextPos.pop() - 1,
+          indexInPos = this.nextPos.length,
+          seriesBeginIndex = this.seriesIndexes.pop(),
+          seriesEndIndex = this.nodes.length;
+      for (var i = seriesBeginIndex; i < seriesEndIndex; ++i) {
+        console.assert(indexInPos < this.lasts[i].length);
+        console.assert(undefined === this.lasts[i][indexInPos]);
+        this.lasts[i][indexInPos] = last;
+      }
+    },
+    finalize: function() {
+      if (null == this.nextPos) return this;
+      console.assert(0 === this.nextPos.length);
+      var lastsJSON = JSON.stringify(this.lasts);
+      for (var i = 0; i < this.lasts.length; ++i) {
+        for (var j = 0; j < this.lasts[i].length; ++j) {
+          console.assert(null != this.lasts[i][j], i + ',' + j + ':' + lastsJSON);
+        }
+      }
+      this.pushSeries = this.popSeries = this.addNode = function() {
+        throw new Error('Already finalized.');
+      };
+      return this;
+    },
+    addNode: function addNode(node) {
+      console.assert(node);
+      this._pushToNodes.call(this.nodes, node)
+      this._pushToNodes.call(this.pos, this.nextPos.slice());
+      this._pushToNodes.call(this.lasts, new Array(this.nextPos.length));
+      for (var i = 0; i < this.nextPos.length; ++i) this.nextPos[i]++;
+    },
+    simplify: function() {
+      this.finalize();
+      return {nodes:this.nodes, pos:this.pos, lasts:this.lasts};
+    }
+  };
+  function eachContext(nodeMultiSet) {
+    var r = [];
+    for (var i = 0; i < nodeMultiSet.nodes.length; i++) {
+      var node = nodeMultiSet.nodes[i];
+      if (!nodeMultiSet.pos) {
+        r.push({nodes:[node], pos: [[i + 1]], lasts: [[nodeMultiSet.nodes.length]]});
+      } else {
+        for (var j = 0; j < nodeMultiSet.pos[i].length; ++j) {
+          r.push({nodes:[node], pos: [[nodeMultiSet.pos[i][j]]], lasts: [[nodeMultiSet.lasts[i][j]]]});
+        }
+      }
+    }
+    return r;
+  }
+  /** Matcher used in the axes.
+   */
+  function NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase) {
+    this.nodeTypeNum = nodeTypeNum;
+    this.nodeName = nodeName;
+    this.shouldLowerCase = shouldLowerCase;
+    this.nodeNameTest =
+      null == nodeName ? this._alwaysTrue :
+      shouldLowerCase ? this._nodeNameLowerCaseEquals :
+      this._nodeNameEquals;
+  }
+  NodeMatcher.prototype = {
+    matches: function matches(node) {
+      if (0 === this.nodeTypeNum || this._nodeTypeMatches(node)) {
+        return this.nodeNameTest(getNodeName(node));
+      }
+
+      return false;
+    },
+    _nodeTypeMatches(nodeOrAttr) {
+      if (nodeOrAttr.constructor.name === 'Attr' && this.nodeTypeNum === 2) {
+        return true;
+      }
+      return nodeOrAttr.nodeType === this.nodeTypeNum;
+    },
+    _alwaysTrue: function(name) {return true;},
+    _nodeNameEquals: function _nodeNameEquals(name) {
+      return this.nodeName === name;
+    },
+    _nodeNameLowerCaseEquals: function _nodeNameLowerCaseEquals(name) {
+      return this.nodeName === name.toLowerCase();
+    }
+  };
+
+  function followingSiblingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, shift, peek, followingNode, andSelf, isReverseAxis) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var nodeMultiSet = new NodeMultiSet(isReverseAxis);
+    while (0 < nodeList.length) {  // can be if for following, preceding
+      var node = shift.call(nodeList);
+      console.assert(node != null);
+      node = followingNode(node);
+      nodeMultiSet.pushSeries();
+      var numPushed = 1;
+      while (null != node) {
+        if (! andSelf && matcher.matches(node))
+          nodeMultiSet.addNode(node);
+        if (node === peek.call(nodeList)) {
+          shift.call(nodeList);
+          nodeMultiSet.pushSeries();
+          numPushed++;
+        }
+        if (andSelf && matcher.matches(node))
+          nodeMultiSet.addNode(node);
+        node = followingNode(node);
+      }
+      while (0 < numPushed--)
+        nodeMultiSet.popSeries();
+    }
+    return nodeMultiSet;
+  }
+
+  /** Returns the next non-descendant node in document order.
+   * This is the first node in following::node(), if node is the context.
+   */
+  function followingNonDescendantNode(node) {
+    if (node.ownerElement) {
+      if (node.ownerElement.firstChild)
+        return node.ownerElement.firstChild;
+      node = node.ownerElement;
+    }
+    do {
+      if (node.nextSibling) return node.nextSibling;
+    } while (node = node.parentNode);
+    return null;
+  }
+
+  /** Returns the next node in a document-order depth-first search.
+   * See the definition of document order[1]:
+   *   1) element
+   *   2) namespace nodes
+   *   3) attributes
+   *   4) children
+   *   [1]: http://www.w3.org/TR/xpath/#dt-document-order
+   */
+  function followingNode(node) {
+    if (node.ownerElement)  // attributes: following node of element.
+      node = node.ownerElement;
+    if (null != node.firstChild)
+      return node.firstChild;
+    do {
+      if (null != node.nextSibling) {
+        return node.nextSibling;
+      }
+      node = node.parentNode;
+    } while (node);
+    return null;
+  }
+  /** Returns the previous node in document order (excluding attributes
+   * and namespace nodes).
+   */
+  function precedingNode(node) {
+    if (node.ownerElement)
+      return node.ownerElement;
+    if (null != node.previousSibling) {
+      node = node.previousSibling;
+      while (null != node.lastChild) {
+        node = node.lastChild;
+      }
+      return node;
+    }
+    if (null != node.parentNode) {
+      return node.parentNode;
+    }
+    return null;
+  }
+  /** This axis is inefficient if there are many nodes in the nodeList.
+   * But I think it's a pretty useless axis so it's ok. */
+  function followingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var nodeMultiSet = new NodeMultiSet(false);
+    var cursor = nodeList[0];
+    var unorderedFollowingStarts = [];
+    for (var i = 0; i < nodeList.length; i++) {
+      var node = nodeList[i];
+      var start = followingNonDescendantNode(node);
+      if (start)
+        unorderedFollowingStarts.push(start);
+    }
+    if (0 === unorderedFollowingStarts.length)
+      return {nodes:[]};
+    var pos = [], nextPos = [];
+    var started = 0;
+    while (cursor = followingNode(cursor)) {
+      for (var i = unorderedFollowingStarts.length - 1; i >= 0; i--){
+        if (cursor === unorderedFollowingStarts[i]) {
+          nodeMultiSet.pushSeries();
+          unorderedFollowingStarts.splice(i,i+1);
+          started++;
+        }
+      }
+      if (started && matcher.matches(cursor)) {
+        nodeMultiSet.addNode(cursor);
+      }
+    }
+    console.assert(0 === unorderedFollowingStarts.length);
+    for (var i = 0; i < started; i++)
+      nodeMultiSet.popSeries();
+    return nodeMultiSet.finalize();
+  }
+  function precedingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var cursor = nodeList.pop();
+    if (null == cursor) return {nodes:{}};
+    var r = {nodes:[], pos:[], lasts:[]};
+    var nextParents = [cursor.parentNode || cursor.ownerElement], nextPos = [1];
+    while (cursor = precedingNode(cursor)) {
+      if (cursor === nodeList[nodeList.length - 1]) {
+        nextParents.push(nodeList.pop());
+        nextPos.push(1);
+      }
+      var matches = matcher.matches(cursor);
+      var pos, someoneUsed = false;
+      if (matches)
+        pos = nextPos.slice();
+
+      for (var i = 0; i < nextParents.length; ++i) {
+        if (cursor === nextParents[i]) {
+          nextParents[i] = cursor.parentNode || cursor.ownerElement;
+          if (matches) {
+            pos[i] = null;
+          }
+        } else {
+          if (matches) {
+            pos[i] = nextPos[i]++;
+            someoneUsed = true;
+          }
+        }
+      }
+      if (someoneUsed) {
+        r.nodes.unshift(cursor);
+        r.pos.unshift(pos);
+      }
+    }
+    for (var i = 0; i < r.pos.length; ++i) {
+      var lasts = [];
+      r.lasts.push(lasts);
+      for (var j = r.pos[i].length - 1; j >= 0; j--) {
+        if (null == r.pos[i][j]) {
+          r.pos[i].splice(j, j+1);
+        } else {
+          lasts.unshift(nextPos[j] - 1);
+        }
+      }
+    }
+    return r;
+  }
+
+  /** node-set, axis -> node-set */
+  function descendantDfs(nodeMultiSet, node, remaining, matcher, andSelf, attrIndices, attrNodes) {
+    while (0 < remaining.length && null != remaining[0].ownerElement) {
+      var attr = remaining.shift();
+      if (andSelf && matcher.matches(attr)) {
+        attrNodes.push(attr);
+        attrIndices.push(nodeMultiSet.nodes.length);
+      }
+    }
+    if (null != node && !andSelf) {
+      if (matcher.matches(node))
+        nodeMultiSet.addNode(node);
+    }
+    var pushed = false;
+    if (null == node) {
+      if (0 === remaining.length) return;
+      node = remaining.shift();
+      nodeMultiSet.pushSeries();
+      pushed = true;
+    } else if (0 < remaining.length && node === remaining[0]) {
+      nodeMultiSet.pushSeries();
+      pushed = true;
+      remaining.shift();
+    }
+    if (andSelf) {
+      if (matcher.matches(node))
+        nodeMultiSet.addNode(node);
+    }
+    // TODO: use optimization. Also try element.getElementsByTagName
+    // var nodeList = 1 === nodeTypeNum && null != node.children ? node.children : node.childNodes;
+    var nodeList = node.childNodes;
+    for (var j = 0; j < nodeList.length; ++j) {
+      var child = nodeList[j];
+      descendantDfs(nodeMultiSet, child, remaining, matcher, andSelf, attrIndices, attrNodes);
+    }
+    if (pushed) {
+      nodeMultiSet.popSeries();
+    }
+  }
+  function descenantHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, andSelf) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var nodeMultiSet = new NodeMultiSet(false);
+    var attrIndices = [], attrNodes = [];
+    while (0 < nodeList.length) {
+      // var node = nodeList.shift();
+      descendantDfs(nodeMultiSet, null, nodeList, matcher, andSelf, attrIndices, attrNodes);
+    }
+    nodeMultiSet.finalize();
+    for (var i = attrNodes.length-1; i >= 0; --i) {
+      nodeMultiSet.nodes.splice(attrIndices[i], attrIndices[i], attrNodes[i]);
+      nodeMultiSet.pos.splice(attrIndices[i], attrIndices[i], [1]);
+      nodeMultiSet.lasts.splice(attrIndices[i], attrIndices[i], [1]);
+    }
+    return nodeMultiSet;
+  }
+  /**
+   */
+  function ancestorHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, andSelf) {
+    var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+    var ancestors = []; // array of non-empty arrays of matching ancestors
+    for (var i = 0; i < nodeList.length; ++i) {
+      var node = nodeList[i];
+      var isFirst = true;
+      var a = [];
+      while (null != node) {
+        if (!isFirst || andSelf) {
+          if (matcher.matches(node))
+            a.push(node);
+        }
+        isFirst = false;
+        node = node.parentNode || node.ownerElement;
+      }
+      if (0 < a.length)
+        ancestors.push(a);
+    }
+    var lasts = [];
+    for (var i = 0; i < ancestors.length; ++i) lasts.push(ancestors[i].length);
+    var nodeMultiSet = new NodeMultiSet(true);
+    var newCtx = {nodes:[], pos:[], lasts:[]};
+    while (0 < ancestors.length) {
+      var pos = [ancestors[0].length];
+      var last = [lasts[0]];
+      var node = ancestors[0].pop();
+      for (var i = ancestors.length - 1; i > 0; --i) {
+        if (node === ancestors[i][ancestors[i].length - 1]) {
+          pos.push(ancestors[i].length);
+          last.push(lasts[i]);
+          ancestors[i].pop();
+          if (0 === ancestors[i].length) {
+            ancestors.splice(i, i+1);
+            lasts.splice(i, i+1);
+          }
+        }
+      }
+      if (0 === ancestors[0].length) {
+        ancestors.shift();
+        lasts.shift();
+      }
+      newCtx.nodes.push(node);
+      newCtx.pos.push(pos);
+      newCtx.lasts.push(last);
+    }
+    return newCtx;
+  }
+  /** Helper function for sortDocumentOrder. Returns a list of indices, from the
+   * node to the root, of positions within parent.
+   * For convenience, the node is the first element of the array.
+   */
+  function addressVector(node) {
+    var r = [node];
+    if (null != node.ownerElement) {
+      node = node.ownerElement;
+      r.push(-1);
+    }
+    while (null != node) {
+      var i = 0;
+      while (null != node.previousSibling) {
+        node = node.previousSibling;
+        i++;
+      }
+      r.push(i);
+      node = node.parentNode
+    }
+    return r;
+  }
+  function addressComparator(a, b) {
+    var minlen = Math.min(a.length - 1, b.length - 1),  // not including [0]=node
+        alen = a.length,
+        blen = b.length;
+    if (a[0] === b[0]) return 0;
+    var c;
+    for (var i = 0; i < minlen; ++i) {
+      c = a[alen - i - 1] - b[blen - i - 1];
+      if (0 !== c)
+        break;
+    }
+    if (null == c || 0 === c) {
+      // All equal until one of the nodes. The longer one is the descendant.
+      c = alen - blen;
+    }
+    if (0 === c)
+      c = getNodeName(a) - getNodeName(b);
+    if (0 === c)
+      c = 1;
+    return c;
+  }
+  var sortUniqDocumentOrder = xpath.sortUniqDocumentOrder = function(nodes) {
+    var a = [];
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
+      var v = addressVector(node);
+      a.push(v);
+    }
+    a.sort(addressComparator);
+    var b = [];
+    for (var i = 0; i < a.length; i++) {
+      if (0 < i && a[i][0] === a[i - 1][0])
+        continue;
+      b.push(a[i][0]);
+    }
+    return b;
+  }
+  /** Sort node multiset. Does not do any de-duping. */
+  function sortNodeMultiSet(nodeMultiSet) {
+    var a = [];
+    for (var i = 0; i < nodeMultiSet.nodes.length; i++) {
+      var v = addressVector(nodeMultiSet.nodes[i]);
+      a.push({v:v, n:nodeMultiSet.nodes[i],
+              p:nodeMultiSet.pos[i], l:nodeMultiSet.lasts[i]});
+    }
+    a.sort(compare);
+    var r = {nodes:[], pos:[], lasts:[]};
+    for (var i = 0; i < a.length; ++i) {
+      r.nodes.push(a[i].n);
+      r.pos.push(a[i].p);
+      r.lasts.push(a[i].l);
+    }
+    function compare(x, y) {
+      return addressComparator(x.v, y.v);
+    }
+    return r;
+  }
+  /** Returns an array containing all the ancestors down to a node.
+   * The array starts with document.
+   */
+  function nodeAndAncestors(node) {
+    var ancestors = [node];
+    var p = node;
+    while (p = p.parentNode || p.ownerElement) {
+      ancestors.unshift(p);
+    }
+    return ancestors;
+  }
+  function compareSiblings(a, b) {
+    if (a === b) return 0;
+    var c = a;
+    while (c = c.previousSibling) {
+      if (c === b)
+        return 1;  // b < a
+    }
+    c = b;
+    while (c = c.previousSibling) {
+      if (c === a)
+        return -1;  // a < b
+    }
+    throw new Error('a and b are not siblings: ' + xpath.stringifyObject(a) + ' vs ' + xpath.stringifyObject(b));
+  }
+  /** The merge in merge-sort.*/
+  function mergeNodeLists(x, y) {
+    var a, b, aanc, banc, r = [];
+    if ('object' !== typeof x)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Invalid LHS for | operator ' +
+                               '(expected node-set): ' + x);
+    if ('object' !== typeof y)
+      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                               'Invalid LHS for | operator ' +
+                               '(expected node-set): ' + y);
+    while (true) {
+      if (null == a) {
+        a = x.shift();
+        if (null != a)
+          aanc = addressVector(a);
+      }
+      if (null == b) {
+        b = y.shift();
+        if (null != b)
+          banc = addressVector(b);
+      }
+      if (null == a || null == b) break;
+      var c = addressComparator(aanc, banc);
+      if (c < 0) {
+        r.push(a);
+        a = null;
+        aanc = null;
+      } else if (c > 0) {
+        r.push(b);
+        b = null;
+        banc = null;
+      } else if (getNodeName(a) < getNodeName(b)) {  // attributes
+        r.push(a);
+        a = null;
+        aanc = null;
+      } else if (getNodeName(a) > getNodeName(b)) {  // attributes
+        r.push(b);
+        b = null;
+        banc = null;
+      } else if (a !== b) {
+        // choose b arbitrarily
+        r.push(b);
+        b = null;
+        banc = null;
+      } else {
+        console.assert(a === b, c);
+        // just skip b without pushing it.
+        b = null;
+        banc = null;
+      }
+    }
+    while (a) {
+      r.push(a);
+      a = x.shift();
+    }
+    while (b) {
+      r.push(b);
+      b = y.shift();
+    }
+    return r;
+  }
+  function comparisonHelper(test, x, y, isNumericComparison) {
+    var coersion;
+    if (isNumericComparison)
+      coersion = fn.number;
+    else coersion =
+      'boolean' === typeof x || 'boolean' === typeof y ? fn['boolean'] :
+      'number' === typeof x || 'number' === typeof y ? fn.number :
+      fn.string;
+    if ('object' === typeof x && 'object' === typeof y) {
+      var aMap = {};
+      for (var i = 0; i < x.nodes.length; ++i) {
+        var xi = coersion({nodes:[x.nodes[i]]});
+        for (var j = 0; j < y.nodes.length; ++j) {
+          var yj = coersion({nodes:[y.nodes[j]]});
+          if (test(xi, yj)) return true;
+        }
+      }
+      return false;
+    } else if ('object' === typeof x && x.nodes && x.nodes.length) {
+      for (var i = 0; i < x.nodes.length; ++i) {
+        var xi = coersion({nodes:[x.nodes[i]]}), yc = coersion(y);
+        if (test(xi, yc))
+          return true;
+      }
+      return false;
+    } else if ('object' === typeof y && x.nodes && x.nodes.length) {
+      for (var i = 0; i < x.nodes.length; ++i) {
+        var yi = coersion({nodes:[y.nodes[i]]}), xc = coersion(x);
+        if (test(xc, yi))
+          return true;
+      }
+      return false;
+    } else {
+      var xc = coersion(x), yc = coersion(y);
+      return test(xc, yc);
+    }
+  }
+  var axes = xpath.axes = {
+    'ancestor':
+      function ancestor(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return ancestorHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, false);
+      },
+    'ancestor-or-self':
+      function ancestorOrSelf(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return ancestorHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, true);
+      },
+    'attribute':
+      function attribute(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        // TODO: figure out whether positions should be undefined here.
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        var nodeMultiSet = new NodeMultiSet(false);
+        if (null != nodeName) {
+          // TODO: with namespace
+          for (var i = 0; i < nodeList.length; ++i) {
+            var node = nodeList[i];
+            if (null == node.getAttributeNode)
+              continue;  // only Element has .getAttributeNode
+            var attr = node.getAttributeNode(nodeName);
+            if (null != attr && matcher.matches(attr)) {
+              nodeMultiSet.pushSeries();
+              nodeMultiSet.addNode(attr);
+              nodeMultiSet.popSeries();
+            }
+          }
+        } else {
+          for (var i = 0; i < nodeList.length; ++i) {
+            var node = nodeList[i];
+            if (null != node.attributes) {
+              nodeMultiSet.pushSeries();
+              for (var j = 0; j < node.attributes.length; j++) {  // all nodes have .attributes
+                var attr = node.attributes[j];
+                if (matcher.matches(attr))  // TODO: I think this check is unnecessary
+                  nodeMultiSet.addNode(attr);
+              }
+              nodeMultiSet.popSeries();
+            }
+          }
+        }
+        return nodeMultiSet.finalize();
+      },
+    'child':
+      function child(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        var nodeMultiSet = new NodeMultiSet(false);
+        for (var i = 0; i < nodeList.length; ++i) {
+          var n = nodeList[i];
+          if (n.ownerElement)  // skip attribute nodes' text child.
+            continue;
+          if (n.childNodes) {
+            nodeMultiSet.pushSeries();
+            var childList = 1 === nodeTypeNum && null != n.children ?
+                n.children : n.childNodes;
+            for (var j = 0; j < childList.length; ++j) {
+              var child = childList[j];
+              if (matcher.matches(child)) {
+                nodeMultiSet.addNode(child);
+              }
+              // don't have to do de-duping because children have parent,
+              // which are current context.
+            }
+            nodeMultiSet.popSeries();
+          }
+        }
+        nodeMultiSet.finalize();
+        return sortNodeMultiSet(nodeMultiSet);
+      },
+    'descendant':
+      function descenant(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return descenantHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, false);
+      },
+    'descendant-or-self':
+      function descenantOrSelf(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return descenantHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase, true);
+      },
+    'following':
+      function following(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return followingHelper(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase);
+      },
+    'following-sibling':
+      function followingSibling(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return followingSiblingHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase,
+          Array.prototype.shift, function() {return this[0];},
+          function(node) {return node.nextSibling;});
+      },
+    'namespace':
+      function namespace(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        // TODO
+      },
+    'parent':
+      function parent(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        var nodes = [], pos = [];
+        for (var i = 0; i < nodeList.length; ++i) {
+          var parent = nodeList[i].parentNode || nodeList[i].ownerElement;
+          if (null == parent)
+            continue;
+          if (!matcher.matches(parent))
+            continue;
+          if (nodes.length > 0 && parent === nodes[nodes.length-1])
+            continue;
+          nodes.push(parent);
+          pos.push([1]);
+        }
+        return {nodes:nodes, pos:pos, lasts:pos};
+      },
+    'preceding':
+      function preceding(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return precedingHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase);
+      },
+    'preceding-sibling':
+      function precedingSibling(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        return followingSiblingHelper(
+          nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase,
+          Array.prototype.pop, function() {return this[this.length-1];},
+          function(node) {return node.previousSibling},
+          false, true);
+      },
+    'self':
+      function self(nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase) {
+        var nodes = [], pos = [];
+        var matcher = new NodeMatcher(nodeTypeNum, nodeName, shouldLowerCase);
+        for (var i = 0; i < nodeList.length; ++i) {
+          if (matcher.matches(nodeList[i])) {
+            nodes.push(nodeList[i]);
+            pos.push([1]);
+          }
+        }
+        return {nodes: nodes, pos: pos, lasts: pos}
+      }
+  };
+
+  /***************************************************************************
+   *                         Evaluation: functions                           *
+   ***************************************************************************/
+  var fn = {
+    'number': function number(optObject) {
+      if ('number' === typeof optObject)
+        return optObject;
+      if ('string' === typeof optObject)
+        return parseFloat(optObject);  // note: parseFloat(' ') -> NaN, unlike +' ' -> 0.
+      if ('boolean' === typeof optObject)
+        return +optObject;
+      return fn.number(fn.string.call(this, optObject));  // for node-sets
+    },
+    'string': function string(optObject) {
+      if (null == optObject)
+        return fn.string(this);
+      if ('string' === typeof optObject || 'boolean' === typeof optObject ||
+          'number' === typeof optObject)
+        return '' + optObject;
+      if (0 == optObject.nodes.length) return '';
+      if (null != optObject.nodes[0].textContent)
+        return optObject.nodes[0].textContent;
+      return optObject.nodes[0].nodeValue;
+    },
+    'boolean': function booleanVal(x) {
+      return 'object' === typeof x ? x.nodes.length > 0 : !!x;
+    },
+    'last': function last() {
+      console.assert(Array.isArray(this.pos));
+      console.assert(Array.isArray(this.lasts));
+      console.assert(1 === this.pos.length);
+      console.assert(1 === this.lasts.length);
+      console.assert(1 === this.lasts[0].length);
+      return this.lasts[0][0];
+    },
+    'position': function position() {
+      console.assert(Array.isArray(this.pos));
+      console.assert(Array.isArray(this.lasts));
+      console.assert(1 === this.pos.length);
+      console.assert(1 === this.lasts.length);
+      console.assert(1 === this.pos[0].length);
+      return this.pos[0][0];
+    },
+    'count': function count(nodeSet) {
+      if ('object' !== typeof nodeSet)
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Position ' + stream.position() +
+                                 ': Function count(node-set) ' +
+                                 'got wrong argument type: ' + nodeSet);
+      return nodeSet.nodes.length;
+    },
+    'id': function id(object) {
+      var r = {nodes: []};
+      var doc = this.nodes[0].ownerDocument || this.nodes[0];
+      console.assert(doc);
+      var ids;
+      if ('object' === typeof object) {
+        // for node-sets, map id over each node value.
+        ids = [];
+        for (var i = 0; i < object.nodes.length; ++i) {
+          var idNode = object.nodes[i];
+          var idsString = fn.string({nodes:[idNode]});
+          var a = idsString.split(/[ \t\r\n]+/g);
+          Array.prototype.push.apply(ids, a);
+        }
+      } else {
+        var idsString = fn.string(object);
+        var a = idsString.split(/[ \t\r\n]+/g);
+        ids = a;
+      }
+      for (var i = 0; i < ids.length; ++i) {
+        var id = ids[i];
+        if (0 === id.length)
+          continue;
+        var node = doc.getElementById(id);
+        if (null != node)
+          r.nodes.push(node);
+      }
+      r.nodes = sortUniqDocumentOrder(r.nodes);
+      return r;
+    },
+    'local-name': function(nodeSet) {
+      if (null == nodeSet)
+        return fn.name(this);
+      if (null == nodeSet.nodes) {
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'argument to name() must be a node-set. got ' + nodeSet);
+      }
+      // TODO: namespaced version
+      return nodeSet.nodes[0].localName;
+    },
+    'namespace-uri': function(nodeSet) {
+      // TODO
+      throw new Error('not implemented yet');
+    },
+    'name': function(nodeSet) {
+      if (null == nodeSet)
+        return fn.name(this);
+      if (null == nodeSet.nodes) {
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'argument to name() must be a node-set. got ' + nodeSet);
+      }
+      return nodeSet.nodes[0].name;
+    },
+    'concat': function concat(x) {
+      var l = [];
+      for (var i = 0; i < arguments.length; ++i) {
+        l.push(fn.string(arguments[i]));
+      }
+      return l.join('');
+    },
+    'starts-with': function startsWith(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      return as.substr(0, bs.length) === bs;
+    },
+    'contains': function contains(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      var i = as.indexOf(bs);
+      if (-1 === i) return false;
+      return true;
+    },
+    'substring-before': function substringBefore(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      var i = as.indexOf(bs);
+      if (-1 === i) return '';
+      return as.substr(0, i);
+    },
+    'substring-after': function substringBefore(a, b) {
+      var as = fn.string(a), bs = fn.string(b);
+      var i = as.indexOf(bs);
+      if (-1 === i) return '';
+      return as.substr(i + bs.length);
+    },
+    'substring': function substring(string, start, optEnd) {
+      if (null == string || null == start) {
+        throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                 'Must be at least 2 arguments to string()');
+      }
+      var sString = fn.string(string),
+          iStart = fn.round(start),
+          iEnd = optEnd == null ? null : fn.round(optEnd);
+      // Note that xpath string positions user 1-based index
+      if (iEnd == null)
+        return sString.substr(iStart - 1);
+      else
+        return sString.substr(iStart - 1, iEnd);
+    },
+    'string-length': function stringLength(optString) {
+      return fn.string.call(this, optString).length;
+    },
+    'normalize-space': function normalizeSpace(optString) {
+      var s = fn.string.call(this, optString);
+      return s.replace(/[ \t\r\n]+/g, ' ').replace(/^ | $/g, '');
+    },
+    'translate': function translate(string, from, to) {
+      var sString = fn.string.call(this, string),
+          sFrom = fn.string(from),
+          sTo = fn.string(to);
+      var eachCharRe = [];
+      var map = {};
+      for (var i = 0; i < sFrom.length; ++i) {
+        var c = sFrom.charAt(i);
+        map[c] = sTo.charAt(i);  // returns '' if beyond length of sTo.
+        // copied from goog.string.regExpEscape in the Closure library.
+        eachCharRe.push(
+          c.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
+            replace(/\x08/g, '\\x08'));
+      }
+      var re = new RegExp(eachCharRe.join('|'), 'g');
+      return sString.replace(re, function(c) {return map[c];});
+    },
+    /// Boolean functions
+    'not': function not(x) {
+      var bx = fn['boolean'](x);
+      return !bx;
+    },
+    'true': function trueVal() { return true; },
+    'false': function falseVal() { return false; },
+    // TODO
+    'lang': function lang(string) { throw new Error('Not implemented');},
+    'sum': function sum(optNodeSet) {
+      if (null == optNodeSet) return fn.sum(this);
+      // for node-sets, map id over each node value.
+      var sum = 0;
+      for (var i = 0; i < optNodeSet.nodes.length; ++i) {
+        var node = optNodeSet.nodes[i];
+        var x = fn.number({nodes:[node]});
+        sum += x;
+      }
+      return sum;
+    },
+    'floor': function floor(number) {
+      return Math.floor(fn.number(number));
+    },
+    'ceiling': function ceiling(number) {
+      return Math.ceil(fn.number(number));
+    },
+    'round': function round(number) {
+      return Math.round(fn.number(number));
+    }
+  };
+  /***************************************************************************
+   *                         Evaluation: operators                           *
+   ***************************************************************************/
+  var more = {
+    UnaryMinus: function(x) { return -fn.number(x); },
+    '+': function(x, y) { return fn.number(x) + fn.number(y); },
+    '-': function(x, y) { return fn.number(x) - fn.number(y); },
+    '*': function(x, y) { return fn.number(x) * fn.number(y); },
+    'div': function(x, y) { return fn.number(x) / fn.number(y); },
+    'mod': function(x, y) { return fn.number(x) % fn.number(y); },
+    '<': function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) < fn.number(y);}, x, y, true);
+    },
+    '<=': function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) <= fn.number(y);}, x, y, true);
+    },
+    '>':  function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) > fn.number(y);}, x, y, true);
+    },
+    '>=': function(x, y) {
+      return comparisonHelper(function(x, y) { return fn.number(x) >= fn.number(y);}, x, y, true);
+    },
+    'and': function(x, y) { return fn['boolean'](x) && fn['boolean'](y); },
+    'or': function(x, y) { return fn['boolean'](x) || fn['boolean'](y); },
+    '|': function(x, y) { return {nodes: mergeNodeLists(x.nodes, y.nodes)}; },
+    '=': function(x, y) {
+      // optimization for two node-sets case: avoid n^2 comparisons.
+      if ('object' === typeof x && 'object' === typeof y) {
+        var aMap = {};
+        for (var i = 0; i < x.nodes.length; ++i) {
+          var s = fn.string({nodes:[x.nodes[i]]});
+          aMap[s] = true;
+        }
+        for (var i = 0; i < y.nodes.length; ++i) {
+          var s = fn.string({nodes:[y.nodes[i]]});
+          if (aMap[s]) return true;
+        }
+        return false;
+      } else {
+        return comparisonHelper(function(x, y) {return x === y;}, x, y);
+      }
+    },
+    '!=': function(x, y) {
+      // optimization for two node-sets case: avoid n^2 comparisons.
+      if ('object' === typeof x && 'object' === typeof y) {
+        if (0 === x.nodes.length || 0 === y.nodes.length) return false;
+        var aMap = {};
+        for (var i = 0; i < x.nodes.length; ++i) {
+          var s = fn.string({nodes:[x.nodes[i]]});
+          aMap[s] = true;
+        }
+        for (var i = 0; i < y.nodes.length; ++i) {
+          var s = fn.string({nodes:[y.nodes[i]]});
+          if (!aMap[s]) return true;
+        }
+        return false;
+      } else {
+        return comparisonHelper(function(x, y) {return x !== y;}, x, y);
+      }
+    }
+  };
+  var nodeTypes = xpath.nodeTypes = {
+    'node': 0,
+    'attribute': 2,
+    'comment': 8, // this.doc.COMMENT_NODE,
+    'text': 3, // this.doc.TEXT_NODE,
+    'processing-instruction': 7, // this.doc.PROCESSING_INSTRUCTION_NODE,
+    'element': 1  //this.doc.ELEMENT_NODE
+  };
+  /** For debugging and unit tests: returnjs a stringified version of the
+   * argument. */
+  var stringifyObject = xpath.stringifyObject = function stringifyObject(ctx) {
+    var seenKey = 'seen' + Math.floor(Math.random()*1000000000);
+    return JSON.stringify(helper(ctx));
+
+    function helper(ctx) {
+      if (Array.isArray(ctx)) {
+        return ctx.map(function(x) {return helper(x);});
+      }
+      if ('object' !== typeof ctx) return ctx;
+      if (null == ctx) return ctx;
+    //  if (ctx.toString) return ctx.toString();
+      if (null != ctx.outerHTML) return ctx.outerHTML;
+      if (null != ctx.nodeValue) return ctx.nodeName + '=' + ctx.nodeValue;
+      if (ctx[seenKey]) return '[circular]';
+      ctx[seenKey] = true;
+      var nicer = {};
+      for (var key in ctx) {
+        if (seenKey === key)
+          continue;
+        try {
+          nicer[key] = helper(ctx[key]);
+        } catch (e) {
+          nicer[key] = '[exception: ' + e.message + ']';
+        }
+      }
+      delete ctx[seenKey];
+      return nicer;
+    }
+  }
+  var Evaluator = xpath.Evaluator = function Evaluator(doc) {
+    this.doc = doc;
+  }
+  Evaluator.prototype = {
+    val: function val(ast, ctx) {
+      console.assert(ctx.nodes);
+
+      if ('number' === typeof ast || 'string' === typeof ast) return ast;
+      if (more[ast[0]]) {
+        var evaluatedParams = [];
+        for (var i = 1; i < ast.length; ++i) {
+          evaluatedParams.push(this.val(ast[i], ctx));
+        }
+        var r = more[ast[0]].apply(ctx, evaluatedParams);
+        return r;
+      }
+      switch (ast[0]) {
+        case 'Root': return {nodes: [this.doc]};
+        case 'FunctionCall':
+          var functionName = ast[1], functionParams = ast[2];
+          if (null == fn[functionName])
+            throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
+                                     'Unknown function: ' + functionName);
+          var evaluatedParams = [];
+          for (var i = 0; i < functionParams.length; ++i) {
+            evaluatedParams.push(this.val(functionParams[i], ctx));
+          }
+          var r = fn[functionName].apply(ctx, evaluatedParams);
+          return r;
+        case 'Predicate':
+          var lhs = this.val(ast[1], ctx);
+          var ret = {nodes: []};
+          var contexts = eachContext(lhs);
+          for (var i = 0; i < contexts.length; ++i) {
+            var singleNodeSet = contexts[i];
+            var rhs = this.val(ast[2], singleNodeSet);
+            var success;
+            if ('number' === typeof rhs) {
+              success = rhs === singleNodeSet.pos[0][0];
+            } else {
+              success = fn['boolean'](rhs);
+            }
+            if (success) {
+              var node = singleNodeSet.nodes[0];
+              ret.nodes.push(node);
+              // skip over all the rest of the same node.
+              while (i+1 < contexts.length && node === contexts[i+1].nodes[0]) {
+                i++;
+              }
+            }
+          }
+          return ret;
+        case 'PathExpr':
+          // turn the path into an expressoin; i.e., remove the position
+          // information of the last axis.
+          var x = this.val(ast[1], ctx);
+          // Make the nodeset a forward-direction-only one.
+          if (x.finalize) {  // it is a NodeMultiSet
+            return {nodes: x.nodes};
+          } else {
+            return x;
+          }
+        case '/':
+          // TODO: don't generate '/' nodes, just Axis nodes.
+          var lhs = this.val(ast[1], ctx);
+          console.assert(null != lhs);
+          var r = this.val(ast[2], lhs);
+          console.assert(null != r);
+          return r;
+        case 'Axis':
+          // All the axis tests from Step. We only get AxisSpecifier NodeTest,
+          // not the predicate (which is applied later)
+          var axis = ast[1],
+              nodeType = ast[2],
+              nodeTypeNum = nodeTypes[nodeType],
+              shouldLowerCase = true,  // TODO: give option
+              nodeName = ast[3] && shouldLowerCase ? ast[3].toLowerCase() : ast[3];
+          nodeName = nodeName === '*' ? null : nodeName;
+          if ('object' !== typeof ctx) return {nodes:[], pos:[]};
+          var nodeList = ctx.nodes.slice();  // TODO: is copy needed?
+          var r = axes[axis](nodeList  /*destructive!*/, nodeTypeNum, nodeName, shouldLowerCase);
+          return r;
+      }
+    }
+  };
+  var evaluate = xpath.evaluate = function evaluate(expr, doc, context) {
+    //var astFactory = new AstEvaluatorFactory(doc, context);
+    var stream = new Stream(expr);
+    var ast = parse(stream, astFactory);
+    var val = new Evaluator(doc).val(ast, {nodes: [context]});
+    return val;
+  }
+
+  /***************************************************************************
+   *                           DOM interface                                 *
+   ***************************************************************************/
+  var XPathException = xpath.XPathException = function XPathException(code, message) {
+    var e = new Error(message);
+    e.name = 'XPathException';
+    e.code = code;
+    return e;
+  }
+  XPathException.INVALID_EXPRESSION_ERR = 51;
+  XPathException.TYPE_ERR = 52;
+
+
+  var XPathEvaluator = xpath.XPathEvaluator = function XPathEvaluator() {}
+  XPathEvaluator.prototype = {
+    createExpression: function(expression, resolver) {
+      return new XPathExpression(expression, resolver);
+    },
+    createNSResolver: function(nodeResolver) {
+      // TODO
+    },
+    evaluate: function evaluate(expression, contextNode, resolver, type, result) {
+      var expr = new XPathExpression(expression, resolver);
+      return expr.evaluate(contextNode, type, result);
+    }
+  };
+
+
+  var XPathExpression = xpath.XPathExpression = function XPathExpression(expression, resolver, optDoc) {
+    var stream = new Stream(expression);
+    this._ast = parse(stream, astFactory);
+    this._doc = optDoc;
+  }
+  XPathExpression.prototype = {
+    evaluate: function evaluate(contextNode, type, result) {
+      if (null == contextNode.nodeType)
+        throw new Error('bad argument (expected context node): ' + contextNode);
+      var doc = contextNode.ownerDocument || contextNode;
+      if (null != this._doc && this._doc !== doc) {
+        throw new core.DOMException(
+            core.DOMException.WRONG_DOCUMENT_ERR,
+            'The document must be the same as the context node\'s document.');
+      }
+      var evaluator = new Evaluator(doc);
+      var value = evaluator.val(this._ast, {nodes: [contextNode]});
+      if (XPathResult.NUMBER_TYPE === type)
+        value = fn.number(value);
+      else if (XPathResult.STRING_TYPE === type)
+        value = fn.string(value);
+      else if (XPathResult.BOOLEAN_TYPE === type)
+        value = fn['boolean'](value);
+      else if (XPathResult.ANY_TYPE !== type &&
+               XPathResult.UNORDERED_NODE_ITERATOR_TYPE !== type &&
+               XPathResult.ORDERED_NODE_ITERATOR_TYPE !== type &&
+               XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE !== type &&
+               XPathResult.ORDERED_NODE_SNAPSHOT_TYPE !== type &&
+               XPathResult.ANY_UNORDERED_NODE_TYPE !== type &&
+               XPathResult.FIRST_ORDERED_NODE_TYPE !== type)
+        throw new core.DOMException(
+            core.DOMException.NOT_SUPPORTED_ERR,
+            'You must provide an XPath result type (0=any).');
+      else if (XPathResult.ANY_TYPE !== type &&
+               'object' !== typeof value)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'Value should be a node-set: ' + value);
+      return new XPathResult(doc, value, type);
+    }
+  }
+
+  var XPathResult = xpath.XPathResult = function XPathResult(doc, value, resultType) {
+    this._value = value;
+    this._resultType = resultType;
+    this._i = 0;
+
+    // TODO: we removed mutation events but didn't take care of this. No tests fail, so that's nice, but eventually we
+    // should fix this, preferably by entirely replacing our XPath implementation.
+    // this._invalidated = false;
+    // if (this.resultType === XPathResult.UNORDERED_NODE_ITERATOR_TYPE ||
+    //     this.resultType === XPathResult.ORDERED_NODE_ITERATOR_TYPE) {
+    //   doc.addEventListener('DOMSubtreeModified', invalidate, true);
+    //   var self = this;
+    //   function invalidate() {
+    //     self._invalidated = true;
+    //     doc.removeEventListener('DOMSubtreeModified', invalidate, true);
+    //   }
+    // }
+  }
+  XPathResult.ANY_TYPE = 0;
+  XPathResult.NUMBER_TYPE = 1;
+  XPathResult.STRING_TYPE = 2;
+  XPathResult.BOOLEAN_TYPE = 3;
+  XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
+  XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
+  XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
+  XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
+  XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
+  XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
+  var proto = {
+    // XPathResultType
+    get resultType() {
+      if (this._resultType) return this._resultType;
+      switch (typeof this._value) {
+        case 'number': return XPathResult.NUMBER_TYPE;
+        case 'string': return XPathResult.STRING_TYPE;
+        case 'boolean': return XPathResult.BOOLEAN_TYPE;
+        default: return XPathResult.UNORDERED_NODE_ITERATOR_TYPE;
+      }
+    },
+    get numberValue() {
+      if (XPathResult.NUMBER_TYPE !== this.resultType)
+        throw new XPathException(XPathException.TYPE_ERR,
+                                 'You should have asked for a NUMBER_TYPE.');
+      return this._value;
+    },
+    get stringValue() {
+      if (XPathResult.STRING_TYPE !== this.resultType)
+        throw new XPathException(XPathException.TYPE_ERR,
+                                 'You should have asked for a STRING_TYPE.');
+      return this._value;
+    },
+    get booleanValue() {
+      if (XPathResult.BOOLEAN_TYPE !== this.resultType)
+        throw new XPathException(XPathException.TYPE_ERR,
+                                 'You should have asked for a BOOLEAN_TYPE.');
+      return this._value;
+    },
+    get singleNodeValue() {
+      if (XPathResult.ANY_UNORDERED_NODE_TYPE !== this.resultType &&
+          XPathResult.FIRST_ORDERED_NODE_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a FIRST_ORDERED_NODE_TYPE.');
+      return this._value.nodes[0] || null;
+    },
+    get invalidIteratorState() {
+      if (XPathResult.UNORDERED_NODE_ITERATOR_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_ITERATOR_TYPE !== this.resultType)
+        return false;
+      return !!this._invalidated;
+    },
+    get snapshotLength() {
+      if (XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a ORDERED_NODE_SNAPSHOT_TYPE.');
+      return this._value.nodes.length;
+    },
+    iterateNext: function iterateNext() {
+      if (XPathResult.UNORDERED_NODE_ITERATOR_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_ITERATOR_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a ORDERED_NODE_ITERATOR_TYPE.');
+      if (this.invalidIteratorState)
+        throw new core.DOMException(
+            core.DOMException.INVALID_STATE_ERR,
+            'The document has been mutated since the result was returned');
+      return this._value.nodes[this._i++] || null;
+    },
+    snapshotItem: function snapshotItem(index) {
+      if (XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE !== this.resultType &&
+          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE !== this.resultType)
+        throw new XPathException(
+            XPathException.TYPE_ERR,
+            'You should have asked for a ORDERED_NODE_SNAPSHOT_TYPE.');
+      return this._value.nodes[index] || null;
+    }
+  };
+  // so you can access ANY_TYPE etc. from the instances:
+  XPathResult.prototype = Object.create(XPathResult,
+      Object.keys(proto).reduce(function (descriptors, name) {
+        descriptors[name] = Object.getOwnPropertyDescriptor(proto, name);
+        return descriptors;
+      }, {
+        constructor: {
+          value: XPathResult,
+          writable: true,
+          configurable: true
+        }
+      }));
+
+  core.XPathException = XPathException;
+  core.XPathExpression = XPathExpression;
+  core.XPathResult = XPathResult;
+  core.XPathEvaluator = XPathEvaluator;
+
+  core.Document.prototype.createExpression =
+    XPathEvaluator.prototype.createExpression;
+
+  core.Document.prototype.createNSResolver =
+      XPathEvaluator.prototype.createNSResolver;
+
+  core.Document.prototype.evaluate = XPathEvaluator.prototype.evaluate;
+
+  return xpath; // for tests
+};
diff --git a/lib/jsdom/living/aborting/AbortController-impl.js b/lib/jsdom/living/aborting/AbortController-impl.js
new file mode 100644
index 0000000..92b05f3
--- /dev/null
+++ b/lib/jsdom/living/aborting/AbortController-impl.js
@@ -0,0 +1,17 @@
+"use strict";
+
+const AbortSignal = require("../generated/AbortSignal");
+
+class AbortControllerImpl {
+  constructor(globalObject) {
+    this.signal = AbortSignal.createImpl(globalObject, []);
+  }
+
+  abort() {
+    this.signal._signalAbort();
+  }
+}
+
+module.exports = {
+  implementation: AbortControllerImpl
+};
diff --git a/lib/jsdom/living/aborting/AbortSignal-impl.js b/lib/jsdom/living/aborting/AbortSignal-impl.js
new file mode 100644
index 0000000..de894b2
--- /dev/null
+++ b/lib/jsdom/living/aborting/AbortSignal-impl.js
@@ -0,0 +1,48 @@
+"use strict";
+
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+
+class AbortSignalImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    // make event firing possible
+    this._ownerDocument = globalObject.document;
+
+    this.aborted = false;
+    this.abortAlgorithms = new Set();
+  }
+
+  _signalAbort() {
+    if (this.aborted) {
+      return;
+    }
+    this.aborted = true;
+
+    for (const algorithm of this.abortAlgorithms) {
+      algorithm();
+    }
+    this.abortAlgorithms.clear();
+
+    fireAnEvent("abort", this);
+  }
+
+  _addAlgorithm(algorithm) {
+    if (this.aborted) {
+      return;
+    }
+    this.abortAlgorithms.add(algorithm);
+  }
+
+  _removeAlgorithm(algorithm) {
+    this.abortAlgorithms.delete(algorithm);
+  }
+}
+
+setupForSimpleEventAccessors(AbortSignalImpl.prototype, ["abort"]);
+
+module.exports = {
+  implementation: AbortSignalImpl
+};
diff --git a/lib/jsdom/living/attributes.js b/lib/jsdom/living/attributes.js
new file mode 100644
index 0000000..295dbe0
--- /dev/null
+++ b/lib/jsdom/living/attributes.js
@@ -0,0 +1,312 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const { HTML_NS } = require("./helpers/namespaces");
+const { asciiLowercase } = require("./helpers/strings");
+const { queueAttributeMutationRecord } = require("./helpers/mutation-observers");
+const { enqueueCECallbackReaction } = require("./helpers/custom-elements");
+
+// The following three are for https://dom.spec.whatwg.org/#concept-element-attribute-has. We don't just have a
+// predicate tester since removing that kind of flexibility gives us the potential for better future optimizations.
+
+/* eslint-disable no-restricted-properties */
+
+exports.hasAttribute = function (element, A) {
+  return element._attributeList.includes(A);
+};
+
+exports.hasAttributeByName = function (element, name) {
+  return element._attributesByNameMap.has(name);
+};
+
+exports.hasAttributeByNameNS = function (element, namespace, localName) {
+  return element._attributeList.some(attribute => {
+    return attribute._localName === localName && attribute._namespace === namespace;
+  });
+};
+
+// https://dom.spec.whatwg.org/#concept-element-attributes-change
+exports.changeAttribute = (element, attribute, value) => {
+  const { _localName, _namespace, _value } = attribute;
+
+  queueAttributeMutationRecord(element, _localName, _namespace, _value);
+
+  if (element._ceState === "custom") {
+    enqueueCECallbackReaction(element, "attributeChangedCallback", [
+      _localName,
+      _value,
+      value,
+      _namespace
+    ]);
+  }
+
+  attribute._value = value;
+
+  // Run jsdom hooks; roughly correspond to spec's "An attribute is set and an attribute is changed."
+  element._attrModified(attribute._qualifiedName, value, _value);
+};
+
+// https://dom.spec.whatwg.org/#concept-element-attributes-append
+exports.appendAttribute = function (element, attribute) {
+  const { _localName, _namespace, _value } = attribute;
+  queueAttributeMutationRecord(element, _localName, _namespace, null);
+
+  if (element._ceState === "custom") {
+    enqueueCECallbackReaction(element, "attributeChangedCallback", [
+      _localName,
+      null,
+      _value,
+      _namespace
+    ]);
+  }
+
+  const attributeList = element._attributeList;
+
+  attributeList.push(attribute);
+  attribute._element = element;
+
+  // Sync name cache
+  const name = attribute._qualifiedName;
+  const cache = element._attributesByNameMap;
+  let entry = cache.get(name);
+  if (!entry) {
+    entry = [];
+    cache.set(name, entry);
+  }
+  entry.push(attribute);
+
+  // Run jsdom hooks; roughly correspond to spec's "An attribute is set and an attribute is added."
+  element._attrModified(name, _value, null);
+};
+
+exports.removeAttribute = function (element, attribute) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-remove
+
+  const { _localName, _namespace, _value } = attribute;
+
+  queueAttributeMutationRecord(element, _localName, _namespace, _value);
+
+  if (element._ceState === "custom") {
+    enqueueCECallbackReaction(element, "attributeChangedCallback", [
+      _localName,
+      _value,
+      null,
+      _namespace
+    ]);
+  }
+
+  const attributeList = element._attributeList;
+
+  for (let i = 0; i < attributeList.length; ++i) {
+    if (attributeList[i] === attribute) {
+      attributeList.splice(i, 1);
+      attribute._element = null;
+
+      // Sync name cache
+      const name = attribute._qualifiedName;
+      const cache = element._attributesByNameMap;
+      const entry = cache.get(name);
+      entry.splice(entry.indexOf(attribute), 1);
+      if (entry.length === 0) {
+        cache.delete(name);
+      }
+
+      // Run jsdom hooks; roughly correspond to spec's "An attribute is removed."
+      element._attrModified(name, null, attribute._value);
+
+      return;
+    }
+  }
+};
+
+exports.replaceAttribute = function (element, oldAttr, newAttr) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-replace
+
+  const { _localName, _namespace, _value } = oldAttr;
+
+  queueAttributeMutationRecord(element, _localName, _namespace, _value);
+
+  if (element._ceState === "custom") {
+    enqueueCECallbackReaction(element, "attributeChangedCallback", [
+      _localName,
+      _value,
+      newAttr._value,
+      _namespace
+    ]);
+  }
+
+  const attributeList = element._attributeList;
+
+  for (let i = 0; i < attributeList.length; ++i) {
+    if (attributeList[i] === oldAttr) {
+      attributeList.splice(i, 1, newAttr);
+      oldAttr._element = null;
+      newAttr._element = element;
+
+      // Sync name cache
+      const name = newAttr._qualifiedName;
+      const cache = element._attributesByNameMap;
+      let entry = cache.get(name);
+      if (!entry) {
+        entry = [];
+        cache.set(name, entry);
+      }
+      entry.splice(entry.indexOf(oldAttr), 1, newAttr);
+
+      // Run jsdom hooks; roughly correspond to spec's "An attribute is set and an attribute is changed."
+      element._attrModified(name, newAttr._value, oldAttr._value);
+
+      return;
+    }
+  }
+};
+
+exports.getAttributeByName = function (element, name) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
+
+  if (element._namespaceURI === HTML_NS &&
+      element._ownerDocument._parsingMode === "html") {
+    name = asciiLowercase(name);
+  }
+
+  const cache = element._attributesByNameMap;
+  const entry = cache.get(name);
+  if (!entry) {
+    return null;
+  }
+
+  return entry[0];
+};
+
+exports.getAttributeByNameNS = function (element, namespace, localName) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-get-by-namespace
+
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  const attributeList = element._attributeList;
+  for (let i = 0; i < attributeList.length; ++i) {
+    const attr = attributeList[i];
+    if (attr._namespace === namespace && attr._localName === localName) {
+      return attr;
+    }
+  }
+
+  return null;
+};
+
+// Both of the following functions implement https://dom.spec.whatwg.org/#concept-element-attributes-get-value.
+// Separated them into two to keep symmetry with other functions.
+exports.getAttributeValue = function (element, localName) {
+  const attr = exports.getAttributeByNameNS(element, null, localName);
+
+  if (!attr) {
+    return "";
+  }
+
+  return attr._value;
+};
+
+exports.getAttributeValueNS = function (element, namespace, localName) {
+  const attr = exports.getAttributeByNameNS(element, namespace, localName);
+
+  if (!attr) {
+    return "";
+  }
+
+  return attr._value;
+};
+
+exports.setAttribute = function (element, attr) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-set
+
+  if (attr._element !== null && attr._element !== element) {
+    throw DOMException.create(element._globalObject, ["The attribute is in use.", "InUseAttributeError"]);
+  }
+
+  const oldAttr = exports.getAttributeByNameNS(element, attr._namespace, attr._localName);
+  if (oldAttr === attr) {
+    return attr;
+  }
+
+  if (oldAttr !== null) {
+    exports.replaceAttribute(element, oldAttr, attr);
+  } else {
+    exports.appendAttribute(element, attr);
+  }
+
+  return oldAttr;
+};
+
+exports.setAttributeValue = function (element, localName, value, prefix, namespace) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-set-value
+
+  if (prefix === undefined) {
+    prefix = null;
+  }
+  if (namespace === undefined) {
+    namespace = null;
+  }
+
+  const attribute = exports.getAttributeByNameNS(element, namespace, localName);
+  if (attribute === null) {
+    const newAttribute = element._ownerDocument._createAttribute({
+      namespace,
+      namespacePrefix: prefix,
+      localName,
+      value
+    });
+    exports.appendAttribute(element, newAttribute);
+
+    return;
+  }
+
+  exports.changeAttribute(element, attribute, value);
+};
+
+// https://dom.spec.whatwg.org/#set-an-existing-attribute-value
+exports.setAnExistingAttributeValue = (attribute, value) => {
+  const element = attribute._element;
+  if (element === null) {
+    attribute._value = value;
+  } else {
+    exports.changeAttribute(element, attribute, value);
+  }
+};
+
+exports.removeAttributeByName = function (element, name) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-name
+
+  const attr = exports.getAttributeByName(element, name);
+
+  if (attr !== null) {
+    exports.removeAttribute(element, attr);
+  }
+
+  return attr;
+};
+
+exports.removeAttributeByNameNS = function (element, namespace, localName) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-namespace
+
+  const attr = exports.getAttributeByNameNS(element, namespace, localName);
+
+  if (attr !== null) {
+    exports.removeAttribute(element, attr);
+  }
+
+  return attr;
+};
+
+exports.attributeNames = function (element) {
+  // Needed by https://dom.spec.whatwg.org/#dom-element-getattributenames
+
+  return element._attributeList.map(a => a._qualifiedName);
+};
+
+exports.hasAttributes = function (element) {
+  // Needed by https://dom.spec.whatwg.org/#dom-element-hasattributes
+
+  return element._attributeList.length > 0;
+};
diff --git a/lib/jsdom/living/attributes/Attr-impl.js b/lib/jsdom/living/attributes/Attr-impl.js
new file mode 100644
index 0000000..e5d4daa
--- /dev/null
+++ b/lib/jsdom/living/attributes/Attr-impl.js
@@ -0,0 +1,60 @@
+"use strict";
+
+const { setAnExistingAttributeValue } = require("../attributes.js");
+const NodeImpl = require("../nodes/Node-impl.js").implementation;
+const { ATTRIBUTE_NODE } = require("../node-type.js");
+
+exports.implementation = class AttrImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._namespace = privateData.namespace !== undefined ? privateData.namespace : null;
+    this._namespacePrefix = privateData.namespacePrefix !== undefined ? privateData.namespacePrefix : null;
+    this._localName = privateData.localName;
+    this._value = privateData.value !== undefined ? privateData.value : "";
+    this._element = privateData.element !== undefined ? privateData.element : null;
+
+    this.nodeType = ATTRIBUTE_NODE;
+    this.specified = true;
+  }
+
+  get namespaceURI() {
+    return this._namespace;
+  }
+
+  get prefix() {
+    return this._namespacePrefix;
+  }
+
+  get localName() {
+    return this._localName;
+  }
+
+  get name() {
+    return this._qualifiedName;
+  }
+
+  get nodeName() {
+    return this._qualifiedName;
+  }
+
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    setAnExistingAttributeValue(this, value);
+  }
+
+  get ownerElement() {
+    return this._element;
+  }
+
+  get _qualifiedName() {
+    // https://dom.spec.whatwg.org/#concept-attribute-qualified-name
+    if (this._namespacePrefix === null) {
+      return this._localName;
+    }
+
+    return this._namespacePrefix + ":" + this._localName;
+  }
+};
diff --git a/lib/jsdom/living/attributes/NamedNodeMap-impl.js b/lib/jsdom/living/attributes/NamedNodeMap-impl.js
new file mode 100644
index 0000000..f244077
--- /dev/null
+++ b/lib/jsdom/living/attributes/NamedNodeMap-impl.js
@@ -0,0 +1,78 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const idlUtils = require("../generated/utils.js");
+const attributes = require("../attributes.js");
+const { HTML_NS } = require("../helpers/namespaces");
+
+exports.implementation = class NamedNodeMapImpl {
+  constructor(globalObject, args, privateData) {
+    this._element = privateData.element;
+
+    this._globalObject = globalObject;
+  }
+  get _attributeList() {
+    return this._element._attributeList;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return this._attributeList.keys();
+  }
+  get length() {
+    return this._attributeList.length;
+  }
+  item(index) {
+    if (index >= this._attributeList.length) {
+      return null;
+    }
+    return this._attributeList[index];
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    const names = new Set(this._attributeList.map(a => a._qualifiedName));
+    const el = this._element;
+    if (el._namespaceURI === HTML_NS && el._ownerDocument._parsingMode === "html") {
+      for (const name of names) {
+        const lowercaseName = name.toLowerCase();
+        if (lowercaseName !== name) {
+          names.delete(name);
+        }
+      }
+    }
+    return names;
+  }
+  getNamedItem(qualifiedName) {
+    return attributes.getAttributeByName(this._element, qualifiedName);
+  }
+  getNamedItemNS(namespace, localName) {
+    return attributes.getAttributeByNameNS(this._element, namespace, localName);
+  }
+  setNamedItem(attr) {
+    // eslint-disable-next-line no-restricted-properties
+    return attributes.setAttribute(this._element, attr);
+  }
+  setNamedItemNS(attr) {
+    // eslint-disable-next-line no-restricted-properties
+    return attributes.setAttribute(this._element, attr);
+  }
+  removeNamedItem(qualifiedName) {
+    const attr = attributes.removeAttributeByName(this._element, qualifiedName);
+    if (attr === null) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to remove an attribute that was not present",
+        "NotFoundError"
+      ]);
+    }
+    return attr;
+  }
+  removeNamedItemNS(namespace, localName) {
+    const attr = attributes.removeAttributeByNameNS(this._element, namespace, localName);
+    if (attr === null) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to remove an attribute that was not present",
+        "NotFoundError"
+      ]);
+    }
+    return attr;
+  }
+};
diff --git a/lib/jsdom/living/constraint-validation/DefaultConstraintValidation-impl.js b/lib/jsdom/living/constraint-validation/DefaultConstraintValidation-impl.js
new file mode 100644
index 0000000..189533a
--- /dev/null
+++ b/lib/jsdom/living/constraint-validation/DefaultConstraintValidation-impl.js
@@ -0,0 +1,75 @@
+"use strict";
+
+const ValidityState = require("../generated/ValidityState");
+const { isDisabled } = require("../helpers/form-controls");
+const { closest } = require("../helpers/traversal");
+const { fireAnEvent } = require("../helpers/events");
+
+exports.implementation = class DefaultConstraintValidationImpl {
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-willvalidate
+  get willValidate() {
+    return this._isCandidateForConstraintValidation();
+  }
+
+  get validity() {
+    if (!this._validity) {
+      this._validity = ValidityState.createImpl(this._globalObject, [], {
+        element: this
+      });
+    }
+    return this._validity;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-checkvalidity
+  checkValidity() {
+    if (!this._isCandidateForConstraintValidation()) {
+      return true;
+    }
+    if (this._satisfiesConstraints()) {
+      return true;
+    }
+    fireAnEvent("invalid", this, undefined, { cancelable: true });
+    return false;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-setcustomvalidity
+  setCustomValidity(message) {
+    this._customValidityErrorMessage = message;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-reportvalidity
+  // Since jsdom has no user interaction, it's the same as #checkValidity
+  reportValidity() {
+    return this.checkValidity();
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-validationmessage
+  get validationMessage() {
+    const { validity } = this;
+    if (!this._isCandidateForConstraintValidation() || this._satisfiesConstraints()) {
+      return "";
+    }
+    const isSufferingFromCustomError = validity.customError;
+    if (isSufferingFromCustomError) {
+      return this._customValidityErrorMessage;
+    }
+    return "Constraints not satisfied";
+  }
+
+  _isCandidateForConstraintValidation() {
+    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-disabled
+    return !isDisabled(this) &&
+      // If an element has a datalist element ancestor,
+      // it is barred from constraint validation.
+      closest(this, "datalist") === null &&
+      !this._barredFromConstraintValidationSpecialization();
+  }
+
+  _isBarredFromConstraintValidation() {
+    return !this._isCandidateForConstraintValidation();
+  }
+
+  _satisfiesConstraints() {
+    return this.validity.valid;
+  }
+};
diff --git a/lib/jsdom/living/constraint-validation/ValidityState-impl.js b/lib/jsdom/living/constraint-validation/ValidityState-impl.js
new file mode 100644
index 0000000..c5bd355
--- /dev/null
+++ b/lib/jsdom/living/constraint-validation/ValidityState-impl.js
@@ -0,0 +1,66 @@
+"use strict";
+
+exports.implementation = class ValidityStateImpl {
+  constructor(globalObject, args, privateData) {
+    const { element, state = {} } = privateData;
+
+    this._element = element;
+    this._state = state;
+  }
+
+  get badInput() {
+    return this._failsConstraint("badInput");
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-a-custom-error
+  get customError() {
+    return this._element._customValidityErrorMessage !== "";
+  }
+
+  get patternMismatch() {
+    return this._failsConstraint("patternMismatch");
+  }
+
+  get rangeOverflow() {
+    return this._failsConstraint("rangeOverflow");
+  }
+
+  get rangeUnderflow() {
+    return this._failsConstraint("rangeUnderflow");
+  }
+
+  get stepMismatch() {
+    return this._failsConstraint("stepMismatch");
+  }
+
+  get tooLong() {
+    return this._failsConstraint("tooLong");
+  }
+
+  get tooShort() {
+    return this._failsConstraint("tooShort");
+  }
+
+  get typeMismatch() {
+    return this._failsConstraint("typeMismatch");
+  }
+
+  get valueMissing() {
+    return this._failsConstraint("valueMissing");
+  }
+
+  _failsConstraint(method) {
+    const validationMethod = this._state[method];
+    if (validationMethod) {
+      return validationMethod();
+    }
+
+    return false;
+  }
+
+  get valid() {
+    return !(this.badInput || this.valueMissing || this.customError ||
+            this.patternMismatch || this.rangeOverflow || this.rangeUnderflow ||
+            this.stepMismatch || this.tooLong || this.tooShort || this.typeMismatch);
+  }
+};
diff --git a/lib/jsdom/living/custom-elements/CustomElementRegistry-impl.js b/lib/jsdom/living/custom-elements/CustomElementRegistry-impl.js
new file mode 100644
index 0000000..bc327c7
--- /dev/null
+++ b/lib/jsdom/living/custom-elements/CustomElementRegistry-impl.js
@@ -0,0 +1,260 @@
+"use strict";
+
+const webIDLConversions = require("webidl-conversions");
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const NODE_TYPE = require("../node-type");
+
+const { HTML_NS } = require("../helpers/namespaces");
+const { getHTMLElementInterface } = require("../helpers/create-element");
+const { shadowIncludingInclusiveDescendantsIterator } = require("../helpers/shadow-dom");
+const { isValidCustomElementName, tryUpgradeElement, enqueueCEUpgradeReaction } = require("../helpers/custom-elements");
+
+const idlUtils = require("../generated/utils");
+const HTMLUnknownElement = require("../generated/HTMLUnknownElement");
+
+const LIFECYCLE_CALLBACKS = [
+  "connectedCallback",
+  "disconnectedCallback",
+  "adoptedCallback",
+  "attributeChangedCallback"
+];
+
+function convertToSequenceDOMString(obj) {
+  if (!obj || !obj[Symbol.iterator]) {
+    throw new TypeError("Invalid Sequence");
+  }
+
+  return Array.from(obj).map(webIDLConversions.DOMString);
+}
+
+// Returns true is the passed value is a valid constructor.
+// Borrowed from: https://stackoverflow.com/a/39336206/3832710
+function isConstructor(value) {
+  if (typeof value !== "function") {
+    return false;
+  }
+
+  try {
+    const P = new Proxy(value, {
+      construct() {
+        return {};
+      }
+    });
+
+    // eslint-disable-next-line no-new
+    new P();
+
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+// https://html.spec.whatwg.org/#customelementregistry
+class CustomElementRegistryImpl {
+  constructor(globalObject) {
+    this._customElementDefinitions = [];
+    this._elementDefinitionIsRunning = false;
+    this._whenDefinedPromiseMap = Object.create(null);
+
+    this._globalObject = globalObject;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-define
+  define(name, ctor, options) {
+    const { _globalObject } = this;
+
+    if (!isConstructor(ctor)) {
+      throw new TypeError("Constructor argument is not a constructor.");
+    }
+
+    if (!isValidCustomElementName(name)) {
+      throw DOMException.create(_globalObject, ["Name argument is not a valid custom element name.", "SyntaxError"]);
+    }
+
+    const nameAlreadyRegistered = this._customElementDefinitions.some(entry => entry.name === name);
+    if (nameAlreadyRegistered) {
+      throw DOMException.create(_globalObject, [
+        "This name has already been registered in the registry.",
+        "NotSupportedError"
+      ]);
+    }
+
+    const ctorAlreadyRegistered = this._customElementDefinitions.some(entry => entry.ctor === ctor);
+    if (ctorAlreadyRegistered) {
+      throw DOMException.create(_globalObject, [
+        "This constructor has already been registered in the registry.",
+        "NotSupportedError"
+      ]);
+    }
+
+    let localName = name;
+
+    let extendsOption = null;
+    if (options !== undefined && options.extends) {
+      extendsOption = options.extends;
+    }
+
+    if (extendsOption !== null) {
+      if (isValidCustomElementName(extendsOption)) {
+        throw DOMException.create(_globalObject, [
+          "Option extends value can't be a valid custom element name.",
+          "NotSupportedError"
+        ]);
+      }
+
+      const extendsInterface = getHTMLElementInterface(extendsOption);
+      if (extendsInterface === HTMLUnknownElement) {
+        throw DOMException.create(_globalObject, [
+          `${extendsOption} is an HTMLUnknownElement.`,
+          "NotSupportedError"
+        ]);
+      }
+
+      localName = extendsOption;
+    }
+
+    if (this._elementDefinitionIsRunning) {
+      throw DOMException.create(_globalObject, [
+        "Invalid nested custom element definition.",
+        "NotSupportedError"
+      ]);
+    }
+
+    this._elementDefinitionIsRunning = true;
+
+    let disableShadow = false;
+    let observedAttributes = [];
+    const lifecycleCallbacks = {
+      connectedCallback: null,
+      disconnectedCallback: null,
+      adoptedCallback: null,
+      attributeChangedCallback: null
+    };
+
+    let caughtError;
+    try {
+      const { prototype } = ctor;
+
+      if (typeof prototype !== "object") {
+        throw new TypeError("Invalid constructor prototype.");
+      }
+
+      for (const callbackName of LIFECYCLE_CALLBACKS) {
+        const callbackValue = prototype[callbackName];
+
+        if (callbackValue !== undefined) {
+          lifecycleCallbacks[callbackName] = webIDLConversions.Function(callbackValue);
+        }
+      }
+
+      if (lifecycleCallbacks.attributeChangedCallback !== null) {
+        const observedAttributesIterable = ctor.observedAttributes;
+
+        if (observedAttributesIterable !== undefined) {
+          observedAttributes = convertToSequenceDOMString(observedAttributesIterable);
+        }
+      }
+
+      let disabledFeatures = [];
+      const disabledFeaturesIterable = ctor.disabledFeatures;
+      if (disabledFeaturesIterable) {
+        disabledFeatures = convertToSequenceDOMString(disabledFeaturesIterable);
+      }
+
+      disableShadow = disabledFeatures.includes("shadow");
+    } catch (err) {
+      caughtError = err;
+    } finally {
+      this._elementDefinitionIsRunning = false;
+    }
+
+    if (caughtError !== undefined) {
+      throw caughtError;
+    }
+
+    const definition = {
+      name,
+      localName,
+      ctor,
+      observedAttributes,
+      lifecycleCallbacks,
+      disableShadow,
+      constructionStack: []
+    };
+
+    this._customElementDefinitions.push(definition);
+
+    const document = idlUtils.implForWrapper(this._globalObject._document);
+
+    const upgradeCandidates = [];
+    for (const candidate of shadowIncludingInclusiveDescendantsIterator(document)) {
+      if (
+        (candidate._namespaceURI === HTML_NS && candidate._localName === localName) &&
+        (extendsOption === null || candidate._isValue === name)
+      ) {
+        upgradeCandidates.push(candidate);
+      }
+    }
+
+    for (const upgradeCandidate of upgradeCandidates) {
+      enqueueCEUpgradeReaction(upgradeCandidate, definition);
+    }
+
+    if (this._whenDefinedPromiseMap[name] !== undefined) {
+      this._whenDefinedPromiseMap[name].resolve(undefined);
+      delete this._whenDefinedPromiseMap[name];
+    }
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-get
+  get(name) {
+    const definition = this._customElementDefinitions.find(entry => entry.name === name);
+    return definition && definition.ctor;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-whendefined
+  whenDefined(name) {
+    if (!isValidCustomElementName(name)) {
+      return Promise.reject(DOMException.create(
+        this._globalObject,
+        ["Name argument is not a valid custom element name.", "SyntaxError"]
+      ));
+    }
+
+    const alreadyRegistered = this._customElementDefinitions.some(entry => entry.name === name);
+    if (alreadyRegistered) {
+      return Promise.resolve();
+    }
+
+    if (this._whenDefinedPromiseMap[name] === undefined) {
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      });
+
+      // Store the pending Promise along with the extracted resolve callback to actually resolve the returned Promise,
+      // once the custom element is registered.
+      this._whenDefinedPromiseMap[name] = {
+        promise,
+        resolve
+      };
+    }
+
+    return this._whenDefinedPromiseMap[name].promise;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-upgrade
+  upgrade(root) {
+    for (const candidate of shadowIncludingInclusiveDescendantsIterator(root)) {
+      if (candidate.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        tryUpgradeElement(candidate);
+      }
+    }
+  }
+}
+
+module.exports = {
+  implementation: CustomElementRegistryImpl
+};
diff --git a/lib/jsdom/living/domparsing/DOMParser-impl.js b/lib/jsdom/living/domparsing/DOMParser-impl.js
new file mode 100644
index 0000000..3877d2b
--- /dev/null
+++ b/lib/jsdom/living/domparsing/DOMParser-impl.js
@@ -0,0 +1,58 @@
+"use strict";
+
+const { parseIntoDocument } = require("../../browser/parser");
+
+const Document = require("../generated/Document");
+
+exports.implementation = class DOMParserImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  parseFromString(string, contentType) {
+    switch (String(contentType)) {
+      case "text/html": {
+        return this.createScriptingDisabledDocument("html", contentType, string);
+      }
+
+      case "text/xml":
+      case "application/xml":
+      case "application/xhtml+xml":
+      case "image/svg+xml": {
+        try {
+          return this.createScriptingDisabledDocument("xml", contentType, string);
+        } catch (error) {
+          const document = this.createScriptingDisabledDocument("xml", contentType);
+          const element = document.createElementNS("http://www.mozilla.org/newlayout/xml/parsererror.xml", "parsererror");
+
+          element.textContent = error.message;
+
+          document.appendChild(element);
+          return document;
+        }
+      }
+
+      default:
+        throw new TypeError("Invalid contentType");
+    }
+  }
+
+  createScriptingDisabledDocument(parsingMode, contentType, string) {
+    const document = Document.createImpl(this._globalObject, [], {
+      options: {
+        parsingMode,
+        encoding: "UTF-8",
+        contentType,
+        readyState: "complete",
+        scriptingDisabled: true
+        // TODO: somehow set URL to active document's URL
+      }
+    });
+
+    if (string !== undefined) {
+      parseIntoDocument(string, document);
+    }
+
+    return document;
+  }
+};
diff --git a/lib/jsdom/living/domparsing/XMLSerializer-impl.js b/lib/jsdom/living/domparsing/XMLSerializer-impl.js
new file mode 100644
index 0000000..5170de8
--- /dev/null
+++ b/lib/jsdom/living/domparsing/XMLSerializer-impl.js
@@ -0,0 +1,18 @@
+"use strict";
+const serialize = require("w3c-xmlserializer");
+const DOMException = require("domexception/webidl2js-wrapper");
+const utils = require("../generated/utils");
+
+exports.implementation = class XMLSerializerImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  serializeToString(root) {
+    try {
+      return serialize(utils.wrapperForImpl(root), { requireWellFormed: false });
+    } catch (e) {
+      throw DOMException.create(this._globalObject, [e.message, "InvalidStateError"]);
+    }
+  }
+};
diff --git a/lib/jsdom/living/domparsing/parse5-adapter-serialization.js b/lib/jsdom/living/domparsing/parse5-adapter-serialization.js
new file mode 100644
index 0000000..e1f1ac7
--- /dev/null
+++ b/lib/jsdom/living/domparsing/parse5-adapter-serialization.js
@@ -0,0 +1,59 @@
+"use strict";
+const nodeTypes = require("../node-type");
+const { domSymbolTree } = require("../helpers/internal-constants");
+// Serialization only requires a subset of the tree adapter interface.
+
+// Tree traversing
+exports.getFirstChild = node => node.firstChild;
+
+exports.getChildNodes = node => node.childNodesForSerializing || domSymbolTree.childrenToArray(node);
+
+exports.getParentNode = node => node.parentNode;
+
+exports.getAttrList = element => {
+  const attributeList = [...element._attributeList];
+
+  if (element._isValue && attributeList.every(attr => attr.name !== "is")) {
+    attributeList.unshift({
+      name: "is",
+      namespace: null,
+      prefix: null,
+      value: element._isValue
+    });
+  }
+
+  return attributeList;
+};
+
+// Node data
+exports.getTagName = element => element._qualifiedName; // https://github.com/inikulin/parse5/issues/231
+
+exports.getNamespaceURI = element => element.namespaceURI;
+
+exports.getTextNodeContent = exports.getCommentNodeContent = node => node.data;
+
+exports.getDocumentTypeNodeName = node => node.name;
+
+exports.getDocumentTypeNodePublicId = node => node.publicId;
+
+exports.getDocumentTypeNodeSystemId = node => node.systemId;
+
+exports.getTemplateContent = templateElement => templateElement._templateContents;
+
+exports.getDocumentMode = document => document._mode;
+
+// Node types
+exports.isTextNode = node => node.nodeType === nodeTypes.TEXT_NODE;
+
+exports.isCommentNode = node => node.nodeType === nodeTypes.COMMENT_NODE;
+
+exports.isDocumentTypeNode = node => node.nodeType === nodeTypes.DOCUMENT_TYPE_NODE;
+
+exports.isElementNode = node => node.nodeType === nodeTypes.ELEMENT_NODE;
+
+// Source code location
+exports.setNodeSourceCodeLocation = (node, location) => {
+  node.sourceCodeLocation = location;
+};
+
+exports.getNodeSourceCodeLocation = node => node.sourceCodeLocation;
diff --git a/lib/jsdom/living/domparsing/serialization.js b/lib/jsdom/living/domparsing/serialization.js
new file mode 100644
index 0000000..6de7674
--- /dev/null
+++ b/lib/jsdom/living/domparsing/serialization.js
@@ -0,0 +1,45 @@
+"use strict";
+
+const produceXMLSerialization = require("w3c-xmlserializer");
+const parse5 = require("parse5");
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const utils = require("../generated/utils");
+const treeAdapter = require("./parse5-adapter-serialization");
+const NODE_TYPE = require("../node-type");
+const NAMESPACES = require("../helpers/namespaces");
+
+function htmlSerialization(node) {
+  if (
+    node.nodeType === NODE_TYPE.ELEMENT_NODE &&
+    node.namespaceURI === NAMESPACES.HTML_NS &&
+    node.tagName === "TEMPLATE"
+  ) {
+    node = node.content;
+  }
+
+  return parse5.serialize(node, { treeAdapter });
+}
+
+module.exports.fragmentSerialization = (node, { requireWellFormed, globalObject }) => {
+  const contextDocument =
+    node.nodeType === NODE_TYPE.DOCUMENT_NODE ? node : node._ownerDocument;
+  if (contextDocument._parsingMode === "html") {
+    return htmlSerialization(node);
+  }
+
+  const childNodes = node.childNodesForSerializing || node.childNodes;
+
+  try {
+    let serialized = "";
+    for (let i = 0; i < childNodes.length; ++i) {
+      serialized += produceXMLSerialization(
+        utils.wrapperForImpl(childNodes[i] || childNodes.item(i)),
+        { requireWellFormed }
+      );
+    }
+    return serialized;
+  } catch (e) {
+    throw DOMException.create(globalObject, [e.message, "InvalidStateError"]);
+  }
+};
diff --git a/lib/jsdom/living/events/CloseEvent-impl.js b/lib/jsdom/living/events/CloseEvent-impl.js
new file mode 100644
index 0000000..83972df
--- /dev/null
+++ b/lib/jsdom/living/events/CloseEvent-impl.js
@@ -0,0 +1,10 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const CloseEventInit = require("../generated/CloseEventInit");
+
+class CloseEventImpl extends EventImpl {}
+CloseEventImpl.defaultInit = CloseEventInit.convert(undefined);
+
+exports.implementation = CloseEventImpl;
diff --git a/lib/jsdom/living/events/CompositionEvent-impl.js b/lib/jsdom/living/events/CompositionEvent-impl.js
new file mode 100644
index 0000000..4932a61
--- /dev/null
+++ b/lib/jsdom/living/events/CompositionEvent-impl.js
@@ -0,0 +1,20 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+const CompositionEventInit = require("../generated/CompositionEventInit");
+
+class CompositionEventImpl extends UIEventImpl {
+  initCompositionEvent(type, bubbles, cancelable, view, data) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, 0);
+    this.data = data;
+  }
+}
+CompositionEventImpl.defaultInit = CompositionEventInit.convert(undefined);
+
+module.exports = {
+  implementation: CompositionEventImpl
+};
diff --git a/lib/jsdom/living/events/CustomEvent-impl.js b/lib/jsdom/living/events/CustomEvent-impl.js
new file mode 100644
index 0000000..5601249
--- /dev/null
+++ b/lib/jsdom/living/events/CustomEvent-impl.js
@@ -0,0 +1,21 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const CustomEventInit = require("../generated/CustomEventInit");
+
+class CustomEventImpl extends EventImpl {
+  initCustomEvent(type, bubbles, cancelable, detail) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.detail = detail;
+  }
+}
+CustomEventImpl.defaultInit = CustomEventInit.convert(undefined);
+
+module.exports = {
+  implementation: CustomEventImpl
+};
diff --git a/lib/jsdom/living/events/ErrorEvent-impl.js b/lib/jsdom/living/events/ErrorEvent-impl.js
new file mode 100644
index 0000000..518551b
--- /dev/null
+++ b/lib/jsdom/living/events/ErrorEvent-impl.js
@@ -0,0 +1,14 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const ErrorEventInit = require("../generated/ErrorEventInit");
+
+class ErrorEventImpl extends EventImpl {
+
+}
+ErrorEventImpl.defaultInit = ErrorEventInit.convert(undefined);
+
+module.exports = {
+  implementation: ErrorEventImpl
+};
diff --git a/lib/jsdom/living/events/Event-impl.js b/lib/jsdom/living/events/Event-impl.js
new file mode 100644
index 0000000..787a66b
--- /dev/null
+++ b/lib/jsdom/living/events/Event-impl.js
@@ -0,0 +1,197 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+const EventInit = require("../generated/EventInit");
+
+class EventImpl {
+  constructor(globalObject, args, privateData) {
+    const [type, eventInitDict = this.constructor.defaultInit] = args;
+
+    this.type = type;
+
+    this.bubbles = false;
+    this.cancelable = false;
+    for (const key in eventInitDict) {
+      if (key in this.constructor.defaultInit) {
+        this[key] = eventInitDict[key];
+      }
+    }
+    for (const key in this.constructor.defaultInit) {
+      if (!(key in this)) {
+        this[key] = this.constructor.defaultInit[key];
+      }
+    }
+
+    this.target = null;
+    this.currentTarget = null;
+    this.eventPhase = 0;
+
+    this._globalObject = globalObject;
+    this._initializedFlag = true;
+    this._stopPropagationFlag = false;
+    this._stopImmediatePropagationFlag = false;
+    this._canceledFlag = false;
+    this._inPassiveListenerFlag = false;
+    this._dispatchFlag = false;
+    this._path = [];
+
+    this.isTrusted = privateData.isTrusted || false;
+    this.timeStamp = Date.now();
+  }
+
+  // https://dom.spec.whatwg.org/#set-the-canceled-flag
+  _setTheCanceledFlag() {
+    if (this.cancelable && !this._inPassiveListenerFlag) {
+      this._canceledFlag = true;
+    }
+  }
+
+  get srcElement() {
+    return this.target;
+  }
+
+  get returnValue() {
+    return !this._canceledFlag;
+  }
+
+  set returnValue(v) {
+    if (v === false) {
+      this._setTheCanceledFlag();
+    }
+  }
+
+  get defaultPrevented() {
+    return this._canceledFlag;
+  }
+
+  stopPropagation() {
+    this._stopPropagationFlag = true;
+  }
+
+  get cancelBubble() {
+    return this._stopPropagationFlag;
+  }
+
+  set cancelBubble(v) {
+    if (v) {
+      this._stopPropagationFlag = true;
+    }
+  }
+
+  stopImmediatePropagation() {
+    this._stopPropagationFlag = true;
+    this._stopImmediatePropagationFlag = true;
+  }
+
+  preventDefault() {
+    this._setTheCanceledFlag();
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-composedpath
+  // Current implementation is based of https://whatpr.org/dom/699.html#dom-event-composedpath
+  // due to a bug in composed path implementation https://github.com/whatwg/dom/issues/684
+  composedPath() {
+    const composedPath = [];
+
+    const { currentTarget, _path: path } = this;
+
+    if (path.length === 0) {
+      return composedPath;
+    }
+
+    composedPath.push(currentTarget);
+
+    let currentTargetIndex = 0;
+    let currentTargetHiddenSubtreeLevel = 0;
+
+    for (let index = path.length - 1; index >= 0; index--) {
+      const { item, rootOfClosedTree, slotInClosedTree } = path[index];
+
+      if (rootOfClosedTree) {
+        currentTargetHiddenSubtreeLevel++;
+      }
+
+      if (item === idlUtils.implForWrapper(currentTarget)) {
+        currentTargetIndex = index;
+        break;
+      }
+
+      if (slotInClosedTree) {
+        currentTargetHiddenSubtreeLevel--;
+      }
+    }
+
+    let currentHiddenLevel = currentTargetHiddenSubtreeLevel;
+    let maxHiddenLevel = currentTargetHiddenSubtreeLevel;
+
+    for (let i = currentTargetIndex - 1; i >= 0; i--) {
+      const { item, rootOfClosedTree, slotInClosedTree } = path[i];
+
+      if (rootOfClosedTree) {
+        currentHiddenLevel++;
+      }
+
+      if (currentHiddenLevel <= maxHiddenLevel) {
+        composedPath.unshift(idlUtils.wrapperForImpl(item));
+      }
+
+      if (slotInClosedTree) {
+        currentHiddenLevel--;
+        if (currentHiddenLevel < maxHiddenLevel) {
+          maxHiddenLevel = currentHiddenLevel;
+        }
+      }
+    }
+
+    currentHiddenLevel = currentTargetHiddenSubtreeLevel;
+    maxHiddenLevel = currentTargetHiddenSubtreeLevel;
+
+    for (let index = currentTargetIndex + 1; index < path.length; index++) {
+      const { item, rootOfClosedTree, slotInClosedTree } = path[index];
+
+      if (slotInClosedTree) {
+        currentHiddenLevel++;
+      }
+
+      if (currentHiddenLevel <= maxHiddenLevel) {
+        composedPath.push(idlUtils.wrapperForImpl(item));
+      }
+
+      if (rootOfClosedTree) {
+        currentHiddenLevel--;
+        if (currentHiddenLevel < maxHiddenLevel) {
+          maxHiddenLevel = currentHiddenLevel;
+        }
+      }
+    }
+
+    return composedPath;
+  }
+
+  _initialize(type, bubbles, cancelable) {
+    this.type = type;
+    this._initializedFlag = true;
+
+    this._stopPropagationFlag = false;
+    this._stopImmediatePropagationFlag = false;
+    this._canceledFlag = false;
+
+    this.isTrusted = false;
+    this.target = null;
+    this.bubbles = bubbles;
+    this.cancelable = cancelable;
+  }
+
+  initEvent(type, bubbles, cancelable) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this._initialize(type, bubbles, cancelable);
+  }
+}
+EventImpl.defaultInit = EventInit.convert(undefined);
+
+module.exports = {
+  implementation: EventImpl
+};
diff --git a/lib/jsdom/living/events/EventModifierMixin-impl.js b/lib/jsdom/living/events/EventModifierMixin-impl.js
new file mode 100644
index 0000000..4603eb9
--- /dev/null
+++ b/lib/jsdom/living/events/EventModifierMixin-impl.js
@@ -0,0 +1,18 @@
+"use strict";
+
+// This mixin doesn't have an IDL equivalent, but since MouseEvent and KeyboardEvent implement getModifierState() the
+// same way, its implementation is shared here.
+
+class EventModifierMixinImpl {
+  // Event's constructor assumes all options correspond to IDL attributes with the same names, and sets them on `this`.
+  // That is not the case for these modifier boolean options, but since the options are set on `this` anyway we'll
+  // access them that way. The spec doesn't say much about the case where keyArg is not one of the valid ones
+  // (https://w3c.github.io/uievents-key/#keys-modifier), but at least Chrome returns false for invalid modifiers. Since
+  // these invalid modifiers will be undefined on `this` (thus `false` after casting it to boolean), we don't need to do
+  // extra checking for validity.
+  getModifierState(keyArg) {
+    return Boolean(this[`modifier${keyArg}`]);
+  }
+}
+
+exports.implementation = EventModifierMixinImpl;
diff --git a/lib/jsdom/living/events/EventTarget-impl.js b/lib/jsdom/living/events/EventTarget-impl.js
new file mode 100644
index 0000000..e7a1862
--- /dev/null
+++ b/lib/jsdom/living/events/EventTarget-impl.js
@@ -0,0 +1,404 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const reportException = require("../helpers/runtime-script-errors");
+const idlUtils = require("../generated/utils");
+const { nodeRoot } = require("../helpers/node");
+const {
+  isNode, isShadowRoot, isSlotable, getEventTargetParent,
+  isShadowInclusiveAncestor, retarget
+} = require("../helpers/shadow-dom");
+
+const MouseEvent = require("../generated/MouseEvent");
+
+const EVENT_PHASE = {
+  NONE: 0,
+  CAPTURING_PHASE: 1,
+  AT_TARGET: 2,
+  BUBBLING_PHASE: 3
+};
+
+class EventTargetImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+    this._eventListeners = Object.create(null);
+  }
+
+  addEventListener(type, callback, options) {
+    // webidl2js currently can't handle neither optional arguments nor callback interfaces
+    if (callback === undefined || callback === null) {
+      callback = null;
+    } else if (typeof callback !== "object" && typeof callback !== "function") {
+      throw new TypeError("Only undefined, null, an object, or a function are allowed for the callback parameter");
+    }
+
+    options = normalizeEventHandlerOptions(options, ["capture", "once", "passive"]);
+
+    if (callback === null) {
+      return;
+    }
+
+    if (!this._eventListeners[type]) {
+      this._eventListeners[type] = [];
+    }
+
+    for (let i = 0; i < this._eventListeners[type].length; ++i) {
+      const listener = this._eventListeners[type][i];
+      if (listener.options.capture === options.capture && listener.callback === callback) {
+        return;
+      }
+    }
+
+    this._eventListeners[type].push({
+      callback,
+      options
+    });
+  }
+
+  removeEventListener(type, callback, options) {
+    if (callback === undefined || callback === null) {
+      callback = null;
+    } else if (typeof callback !== "object" && typeof callback !== "function") {
+      throw new TypeError("Only undefined, null, an object, or a function are allowed for the callback parameter");
+    }
+
+    options = normalizeEventHandlerOptions(options, ["capture"]);
+
+    if (callback === null) {
+      // Optimization, not in the spec.
+      return;
+    }
+
+    if (!this._eventListeners[type]) {
+      return;
+    }
+
+    for (let i = 0; i < this._eventListeners[type].length; ++i) {
+      const listener = this._eventListeners[type][i];
+      if (listener.callback === callback && listener.options.capture === options.capture) {
+        this._eventListeners[type].splice(i, 1);
+        break;
+      }
+    }
+  }
+
+  dispatchEvent(eventImpl) {
+    if (eventImpl._dispatchFlag || !eventImpl._initializedFlag) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to dispatch an uninitialized event",
+        "InvalidStateError"
+      ]);
+    }
+    if (eventImpl.eventPhase !== EVENT_PHASE.NONE) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to dispatch a dispatching event",
+        "InvalidStateError"
+      ]);
+    }
+
+    eventImpl.isTrusted = false;
+
+    return this._dispatch(eventImpl);
+  }
+
+  // https://dom.spec.whatwg.org/#get-the-parent
+  _getTheParent() {
+    return null;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-event-dispatch
+  // legacyOutputDidListenersThrowFlag optional parameter is not necessary here since it is only used by indexDB.
+  _dispatch(eventImpl, targetOverride /* , legacyOutputDidListenersThrowFlag */) {
+    let targetImpl = this;
+    let clearTargets = false;
+    let activationTarget = null;
+
+    eventImpl._dispatchFlag = true;
+
+    targetOverride = targetOverride || targetImpl;
+    let relatedTarget = retarget(eventImpl.relatedTarget, targetImpl);
+
+    if (targetImpl !== relatedTarget || targetImpl === eventImpl.relatedTarget) {
+      const touchTargets = [];
+
+      appendToEventPath(eventImpl, targetImpl, targetOverride, relatedTarget, touchTargets, false);
+
+      const isActivationEvent = MouseEvent.isImpl(eventImpl) && eventImpl.type === "click";
+
+      if (isActivationEvent && targetImpl._hasActivationBehavior) {
+        activationTarget = targetImpl;
+      }
+
+      let slotInClosedTree = false;
+      let slotable = isSlotable(targetImpl) && targetImpl._assignedSlot ? targetImpl : null;
+      let parent = getEventTargetParent(targetImpl, eventImpl);
+
+      // Populate event path
+      // https://dom.spec.whatwg.org/#event-path
+      while (parent !== null) {
+        if (slotable !== null) {
+          if (parent.localName !== "slot") {
+            throw new Error(`JSDOM Internal Error: Expected parent to be a Slot`);
+          }
+
+          slotable = null;
+
+          const parentRoot = nodeRoot(parent);
+          if (isShadowRoot(parentRoot) && parentRoot.mode === "closed") {
+            slotInClosedTree = true;
+          }
+        }
+
+        if (isSlotable(parent) && parent._assignedSlot) {
+          slotable = parent;
+        }
+
+        relatedTarget = retarget(eventImpl.relatedTarget, parent);
+
+        if (
+          (isNode(parent) && isShadowInclusiveAncestor(nodeRoot(targetImpl), parent)) ||
+          idlUtils.wrapperForImpl(parent).constructor.name === "Window"
+        ) {
+          if (isActivationEvent && eventImpl.bubbles && activationTarget === null &&
+              parent._hasActivationBehavior) {
+            activationTarget = parent;
+          }
+
+          appendToEventPath(eventImpl, parent, null, relatedTarget, touchTargets, slotInClosedTree);
+        } else if (parent === relatedTarget) {
+          parent = null;
+        } else {
+          targetImpl = parent;
+
+          if (isActivationEvent && activationTarget === null && targetImpl._hasActivationBehavior) {
+            activationTarget = targetImpl;
+          }
+
+          appendToEventPath(eventImpl, parent, targetImpl, relatedTarget, touchTargets, slotInClosedTree);
+        }
+
+        if (parent !== null) {
+          parent = getEventTargetParent(parent, eventImpl);
+        }
+
+        slotInClosedTree = false;
+      }
+
+      let clearTargetsStructIndex = -1;
+      for (let i = eventImpl._path.length - 1; i >= 0 && clearTargetsStructIndex === -1; i--) {
+        if (eventImpl._path[i].target !== null) {
+          clearTargetsStructIndex = i;
+        }
+      }
+      const clearTargetsStruct = eventImpl._path[clearTargetsStructIndex];
+
+      clearTargets =
+          (isNode(clearTargetsStruct.target) && isShadowRoot(nodeRoot(clearTargetsStruct.target))) ||
+          (isNode(clearTargetsStruct.relatedTarget) && isShadowRoot(nodeRoot(clearTargetsStruct.relatedTarget)));
+
+      if (activationTarget !== null && activationTarget._legacyPreActivationBehavior) {
+        activationTarget._legacyPreActivationBehavior();
+      }
+
+      for (let i = eventImpl._path.length - 1; i >= 0; --i) {
+        const struct = eventImpl._path[i];
+
+        if (struct.target !== null) {
+          eventImpl.eventPhase = EVENT_PHASE.AT_TARGET;
+        } else {
+          eventImpl.eventPhase = EVENT_PHASE.CAPTURING_PHASE;
+        }
+
+        invokeEventListeners(struct, eventImpl, "capturing");
+      }
+
+      for (let i = 0; i < eventImpl._path.length; i++) {
+        const struct = eventImpl._path[i];
+
+        if (struct.target !== null) {
+          eventImpl.eventPhase = EVENT_PHASE.AT_TARGET;
+        } else {
+          if (!eventImpl.bubbles) {
+            continue;
+          }
+
+          eventImpl.eventPhase = EVENT_PHASE.BUBBLING_PHASE;
+        }
+
+        invokeEventListeners(struct, eventImpl, "bubbling");
+      }
+    }
+
+    eventImpl.eventPhase = EVENT_PHASE.NONE;
+
+    eventImpl.currentTarget = null;
+    eventImpl._path = [];
+    eventImpl._dispatchFlag = false;
+    eventImpl._stopPropagationFlag = false;
+    eventImpl._stopImmediatePropagationFlag = false;
+
+    if (clearTargets) {
+      eventImpl.target = null;
+      eventImpl.relatedTarget = null;
+    }
+
+    if (activationTarget !== null) {
+      if (!eventImpl._canceledFlag) {
+        activationTarget._activationBehavior();
+      } else if (activationTarget._legacyCanceledActivationBehavior) {
+        activationTarget._legacyCanceledActivationBehavior();
+      }
+    }
+
+    return !eventImpl._canceledFlag;
+  }
+}
+
+module.exports = {
+  implementation: EventTargetImpl
+};
+
+// https://dom.spec.whatwg.org/#concept-event-listener-invoke
+function invokeEventListeners(struct, eventImpl, phase) {
+  const structIndex = eventImpl._path.indexOf(struct);
+  for (let i = structIndex; i >= 0; i--) {
+    const t = eventImpl._path[i];
+    if (t.target) {
+      eventImpl.target = t.target;
+      break;
+    }
+  }
+
+  eventImpl.relatedTarget = idlUtils.wrapperForImpl(struct.relatedTarget);
+
+  if (eventImpl._stopPropagationFlag) {
+    return;
+  }
+
+  eventImpl.currentTarget = idlUtils.wrapperForImpl(struct.item);
+
+  const listeners = struct.item._eventListeners;
+  innerInvokeEventListeners(eventImpl, listeners, phase, struct);
+}
+
+// https://dom.spec.whatwg.org/#concept-event-listener-inner-invoke
+function innerInvokeEventListeners(eventImpl, listeners, phase) {
+  let found = false;
+
+  const { type, target } = eventImpl;
+  const wrapper = idlUtils.wrapperForImpl(target);
+
+  if (!listeners || !listeners[type]) {
+    return found;
+  }
+
+  // Copy event listeners before iterating since the list can be modified during the iteration.
+  const handlers = listeners[type].slice();
+
+  for (let i = 0; i < handlers.length; i++) {
+    const listener = handlers[i];
+    const { capture, once, passive } = listener.options;
+
+    // Check if the event listener has been removed since the listeners has been cloned.
+    if (!listeners[type].includes(listener)) {
+      continue;
+    }
+
+    found = true;
+
+    if (
+      (phase === "capturing" && !capture) ||
+      (phase === "bubbling" && capture)
+    ) {
+      continue;
+    }
+
+    if (once) {
+      listeners[type].splice(listeners[type].indexOf(listener), 1);
+    }
+
+    if (passive) {
+      eventImpl._inPassiveListenerFlag = true;
+    }
+
+    try {
+      if (typeof listener.callback === "object") {
+        if (typeof listener.callback.handleEvent === "function") {
+          listener.callback.handleEvent(idlUtils.wrapperForImpl(eventImpl));
+        }
+      } else {
+        listener.callback.call(eventImpl.currentTarget, idlUtils.wrapperForImpl(eventImpl));
+      }
+    } catch (e) {
+      let window = null;
+      if (wrapper && wrapper._document) {
+        // Triggered by Window
+        window = wrapper;
+      } else if (target._ownerDocument) {
+        // Triggered by most webidl2js'ed instances
+        window = target._ownerDocument._defaultView;
+      } else if (wrapper._ownerDocument) {
+        // Currently triggered by some non-webidl2js things
+        window = wrapper._ownerDocument._defaultView;
+      }
+
+      if (window) {
+        reportException(window, e);
+      }
+      // Errors in window-less documents just get swallowed... can you think of anything better?
+    }
+
+    eventImpl._inPassiveListenerFlag = false;
+
+    if (eventImpl._stopImmediatePropagationFlag) {
+      return found;
+    }
+  }
+
+  return found;
+}
+
+/**
+ * Normalize the event listeners options argument in order to get always a valid options object
+ * @param   {Object} options         - user defined options
+ * @param   {Array} defaultBoolKeys  - boolean properties that should belong to the options object
+ * @returns {Object} object containing at least the "defaultBoolKeys"
+ */
+function normalizeEventHandlerOptions(options, defaultBoolKeys) {
+  const returnValue = {};
+
+  // no need to go further here
+  if (typeof options === "boolean" || options === null || typeof options === "undefined") {
+    returnValue.capture = Boolean(options);
+    return returnValue;
+  }
+
+  // non objects options so we typecast its value as "capture" value
+  if (typeof options !== "object") {
+    returnValue.capture = Boolean(options);
+    // at this point we don't need to loop the "capture" key anymore
+    defaultBoolKeys = defaultBoolKeys.filter(k => k !== "capture");
+  }
+
+  for (const key of defaultBoolKeys) {
+    returnValue[key] = Boolean(options[key]);
+  }
+
+  return returnValue;
+}
+
+// https://dom.spec.whatwg.org/#concept-event-path-append
+function appendToEventPath(eventImpl, target, targetOverride, relatedTarget, touchTargets, slotInClosedTree) {
+  const itemInShadowTree = isNode(target) && isShadowRoot(nodeRoot(target));
+  const rootOfClosedTree = isShadowRoot(target) && target.mode === "closed";
+
+  eventImpl._path.push({
+    item: target,
+    itemInShadowTree,
+    target: targetOverride,
+    relatedTarget,
+    touchTargets,
+    rootOfClosedTree,
+    slotInClosedTree
+  });
+}
diff --git a/lib/jsdom/living/events/FocusEvent-impl.js b/lib/jsdom/living/events/FocusEvent-impl.js
new file mode 100644
index 0000000..ec8d86d
--- /dev/null
+++ b/lib/jsdom/living/events/FocusEvent-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const FocusEventInit = require("../generated/FocusEventInit");
+
+class FocusEventImpl extends UIEventImpl {}
+FocusEventImpl.defaultInit = FocusEventInit.convert(undefined);
+
+exports.implementation = FocusEventImpl;
diff --git a/lib/jsdom/living/events/HashChangeEvent-impl.js b/lib/jsdom/living/events/HashChangeEvent-impl.js
new file mode 100644
index 0000000..711de8e
--- /dev/null
+++ b/lib/jsdom/living/events/HashChangeEvent-impl.js
@@ -0,0 +1,14 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const HashChangeEventInit = require("../generated/HashChangeEventInit");
+
+class HashChangeEventImpl extends EventImpl {
+
+}
+HashChangeEventImpl.defaultInit = HashChangeEventInit.convert(undefined);
+
+module.exports = {
+  implementation: HashChangeEventImpl
+};
diff --git a/lib/jsdom/living/events/InputEvent-impl.js b/lib/jsdom/living/events/InputEvent-impl.js
new file mode 100644
index 0000000..e8c1daa
--- /dev/null
+++ b/lib/jsdom/living/events/InputEvent-impl.js
@@ -0,0 +1,23 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const InputEventInit = require("../generated/InputEventInit");
+
+// https://w3c.github.io/uievents/#interface-inputevent
+class InputEventImpl extends UIEventImpl {
+  initInputEvent(type, bubbles, cancelable, data, isComposing) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable);
+    this.data = data;
+    this.isComposing = isComposing;
+  }
+}
+InputEventImpl.defaultInit = InputEventInit.convert(undefined);
+
+module.exports = {
+  implementation: InputEventImpl
+};
diff --git a/lib/jsdom/living/events/KeyboardEvent-impl.js b/lib/jsdom/living/events/KeyboardEvent-impl.js
new file mode 100644
index 0000000..e711f4d
--- /dev/null
+++ b/lib/jsdom/living/events/KeyboardEvent-impl.js
@@ -0,0 +1,29 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const EventModifierMixinImpl = require("./EventModifierMixin-impl").implementation;
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const KeyboardEventInit = require("../generated/KeyboardEventInit");
+
+class KeyboardEventImpl extends UIEventImpl {
+  initKeyboardEvent(type, bubbles, cancelable, view, key, location, ctrlKey, altKey, shiftKey, metaKey) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, 0);
+    this.key = key;
+    this.location = location;
+    this.ctrlKey = ctrlKey;
+    this.altKey = altKey;
+    this.shiftKey = shiftKey;
+    this.metaKey = metaKey;
+  }
+}
+mixin(KeyboardEventImpl.prototype, EventModifierMixinImpl.prototype);
+KeyboardEventImpl.defaultInit = KeyboardEventInit.convert(undefined);
+
+module.exports = {
+  implementation: KeyboardEventImpl
+};
diff --git a/lib/jsdom/living/events/MessageEvent-impl.js b/lib/jsdom/living/events/MessageEvent-impl.js
new file mode 100644
index 0000000..eb58e56
--- /dev/null
+++ b/lib/jsdom/living/events/MessageEvent-impl.js
@@ -0,0 +1,25 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const MessageEventInit = require("../generated/MessageEventInit");
+
+class MessageEventImpl extends EventImpl {
+  initMessageEvent(type, bubbles, cancelable, data, origin, lastEventId, source, ports) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.data = data;
+    this.origin = origin;
+    this.lastEventId = lastEventId;
+    this.source = source;
+    this.ports = ports;
+  }
+}
+MessageEventImpl.defaultInit = MessageEventInit.convert(undefined);
+
+module.exports = {
+  implementation: MessageEventImpl
+};
diff --git a/lib/jsdom/living/events/MouseEvent-impl.js b/lib/jsdom/living/events/MouseEvent-impl.js
new file mode 100644
index 0000000..0a7b5c2
--- /dev/null
+++ b/lib/jsdom/living/events/MouseEvent-impl.js
@@ -0,0 +1,36 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const EventModifierMixinImpl = require("./EventModifierMixin-impl").implementation;
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const MouseEventInit = require("../generated/MouseEventInit");
+
+class MouseEventImpl extends UIEventImpl {
+  initMouseEvent(
+    type, bubbles, cancelable, view, detail, screenX, screenY, clientX, clientY,
+    ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget
+  ) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, detail);
+    this.screenX = screenX;
+    this.screenY = screenY;
+    this.clientX = clientX;
+    this.clientY = clientY;
+    this.ctrlKey = ctrlKey;
+    this.altKey = altKey;
+    this.shiftKey = shiftKey;
+    this.metaKey = metaKey;
+    this.button = button;
+    this.relatedTarget = relatedTarget;
+  }
+}
+mixin(MouseEventImpl.prototype, EventModifierMixinImpl.prototype);
+MouseEventImpl.defaultInit = MouseEventInit.convert(undefined);
+
+module.exports = {
+  implementation: MouseEventImpl
+};
diff --git a/lib/jsdom/living/events/PageTransitionEvent-impl.js b/lib/jsdom/living/events/PageTransitionEvent-impl.js
new file mode 100644
index 0000000..ae97b36
--- /dev/null
+++ b/lib/jsdom/living/events/PageTransitionEvent-impl.js
@@ -0,0 +1,20 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const PageTransitionEventInit = require("../generated/PageTransitionEventInit");
+
+// https://html.spec.whatwg.org/multipage/browsing-the-web.html#pagetransitionevent
+class PageTransitionEventImpl extends EventImpl {
+  initPageTransitionEvent(type, bubbles, cancelable, persisted) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.persisted = persisted;
+  }
+}
+PageTransitionEventImpl.defaultInit = PageTransitionEventInit.convert(undefined);
+
+exports.implementation = PageTransitionEventImpl;
diff --git a/lib/jsdom/living/events/PopStateEvent-impl.js b/lib/jsdom/living/events/PopStateEvent-impl.js
new file mode 100644
index 0000000..9c152fb
--- /dev/null
+++ b/lib/jsdom/living/events/PopStateEvent-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+const EventImpl = require("./Event-impl.js").implementation;
+
+const PopStateEventInit = require("../generated/PopStateEventInit");
+
+class PopStateEventImpl extends EventImpl {}
+PopStateEventImpl.defaultInit = PopStateEventInit.convert(undefined);
+
+exports.implementation = PopStateEventImpl;
diff --git a/lib/jsdom/living/events/ProgressEvent-impl.js b/lib/jsdom/living/events/ProgressEvent-impl.js
new file mode 100644
index 0000000..030a9ae
--- /dev/null
+++ b/lib/jsdom/living/events/ProgressEvent-impl.js
@@ -0,0 +1,14 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const ProgressEventInit = require("../generated/ProgressEventInit");
+
+class ProgressEventImpl extends EventImpl {
+
+}
+ProgressEventImpl.defaultInit = ProgressEventInit.convert(undefined);
+
+module.exports = {
+  implementation: ProgressEventImpl
+};
diff --git a/lib/jsdom/living/events/StorageEvent-impl.js b/lib/jsdom/living/events/StorageEvent-impl.js
new file mode 100644
index 0000000..566d0a2
--- /dev/null
+++ b/lib/jsdom/living/events/StorageEvent-impl.js
@@ -0,0 +1,26 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const StorageEventInit = require("../generated/StorageEventInit");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storageevent-interface
+class StorageEventImpl extends EventImpl {
+  initStorageEvent(type, bubbles, cancelable, key, oldValue, newValue, url, storageArea) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.key = key;
+    this.oldValue = oldValue;
+    this.newValue = newValue;
+    this.url = url;
+    this.storageArea = storageArea;
+  }
+}
+StorageEventImpl.defaultInit = StorageEventInit.convert(undefined);
+
+module.exports = {
+  implementation: StorageEventImpl
+};
diff --git a/lib/jsdom/living/events/TouchEvent-impl.js b/lib/jsdom/living/events/TouchEvent-impl.js
new file mode 100644
index 0000000..33635ff
--- /dev/null
+++ b/lib/jsdom/living/events/TouchEvent-impl.js
@@ -0,0 +1,14 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const TouchEventInit = require("../generated/TouchEventInit");
+
+class TouchEventImpl extends UIEventImpl {
+
+}
+TouchEventImpl.defaultInit = TouchEventInit.convert(undefined);
+
+module.exports = {
+  implementation: TouchEventImpl
+};
diff --git a/lib/jsdom/living/events/UIEvent-impl.js b/lib/jsdom/living/events/UIEvent-impl.js
new file mode 100644
index 0000000..a5ef713
--- /dev/null
+++ b/lib/jsdom/living/events/UIEvent-impl.js
@@ -0,0 +1,59 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+const UIEventInit = require("../generated/UIEventInit");
+const EventImpl = require("./Event-impl").implementation;
+
+// Until webidl2js gains support for checking for Window, this would have to do.
+function isWindow(val) {
+  if (typeof val !== "object") {
+    return false;
+  }
+  const wrapper = idlUtils.wrapperForImpl(val);
+  if (typeof wrapper === "object") {
+    return wrapper === wrapper._globalProxy;
+  }
+
+  // `val` may be either impl or wrapper currently, because webidl2js currently unwraps Window objects (and their global
+  // proxies) to their underlying EventTargetImpl during conversion, which is not what we want. But at the same time,
+  // some internal usage call this constructor with the actual global proxy.
+  return isWindow(idlUtils.implForWrapper(val));
+}
+
+class UIEventImpl extends EventImpl {
+  constructor(globalObject, args, privateData) {
+    const eventInitDict = args[1];
+
+    // undefined check included so that we can omit the property in internal usage.
+    if (eventInitDict && eventInitDict.view !== null && eventInitDict.view !== undefined) {
+      if (!isWindow(eventInitDict.view)) {
+        throw new TypeError(`Failed to construct '${new.target.name.replace(/Impl$/, "")}': member view is not of ` +
+                            "type Window.");
+      }
+    }
+
+    super(globalObject, args, privateData);
+  }
+
+  initUIEvent(type, bubbles, cancelable, view, detail) {
+    if (view !== null) {
+      if (!isWindow(view)) {
+        throw new TypeError(`Failed to execute 'initUIEvent' on '${this.constructor.name.replace(/Impl$/, "")}': ` +
+                            "parameter 4 is not of type 'Window'.");
+      }
+    }
+
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.view = view;
+    this.detail = detail;
+  }
+}
+UIEventImpl.defaultInit = UIEventInit.convert(undefined);
+
+module.exports = {
+  implementation: UIEventImpl
+};
diff --git a/lib/jsdom/living/events/WheelEvent-impl.js b/lib/jsdom/living/events/WheelEvent-impl.js
new file mode 100644
index 0000000..82f0cbb
--- /dev/null
+++ b/lib/jsdom/living/events/WheelEvent-impl.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const MouseEventImpl = require("./MouseEvent-impl").implementation;
+
+const WheelEventInit = require("../generated/WheelEventInit");
+
+class WheelEventImpl extends MouseEventImpl {}
+WheelEventImpl.defaultInit = WheelEventInit.convert(undefined);
+
+module.exports = {
+  implementation: WheelEventImpl
+};
diff --git a/lib/jsdom/living/fetch/Headers-impl.js b/lib/jsdom/living/fetch/Headers-impl.js
new file mode 100644
index 0000000..e84ba3f
--- /dev/null
+++ b/lib/jsdom/living/fetch/Headers-impl.js
@@ -0,0 +1,165 @@
+"use strict";
+
+const {
+  isForbidden,
+  isForbiddenResponse,
+  isPrivilegedNoCORSRequest,
+  isNoCORSSafelistedRequest,
+  isCORSWhitelisted
+} = require("./header-types");
+const HeaderList = require("./header-list");
+
+function assertName(name) {
+  if (!name.match(/^[!#$%&'*+\-.^`|~\w]+$/)) {
+    throw new TypeError("name is invalid");
+  }
+}
+
+function assertValue(value) {
+  if (value.match(/[\0\r\n]/)) {
+    throw new TypeError("value is invalid");
+  }
+}
+
+class HeadersImpl {
+  constructor(globalObject, args) {
+    this.guard = "none";
+    this.headersList = new HeaderList();
+
+    if (args[0]) {
+      this._fill(args[0]);
+    }
+  }
+
+  _fill(init) {
+    if (Array.isArray(init)) {
+      for (const header of init) {
+        if (header.length !== 2) {
+          throw new TypeError("init is invalid");
+        }
+        this.append(header[0], header[1]);
+      }
+    } else {
+      for (const key of Object.keys(init)) {
+        this.append(key, init[key]);
+      }
+    }
+  }
+
+  has(name) {
+    assertName(name);
+    return this.headersList.contains(name);
+  }
+
+  get(name) {
+    assertName(name);
+    return this.headersList.get(name);
+  }
+
+  _removePrivilegedNoCORSHeaders() {
+    this.headersList.delete("range");
+  }
+
+  append(name, value) {
+    value = value.trim();
+    assertName(name);
+    assertValue(value);
+
+    switch (this.guard) {
+      case "immutable":
+        throw new TypeError("Headers is immutable");
+      case "request":
+        if (isForbidden(name)) {
+          return;
+        }
+        break;
+      case "request-no-cors": {
+        let temporaryValue = this.get(name);
+        if (temporaryValue === null) {
+          temporaryValue = value;
+        } else {
+          temporaryValue += `, ${value}`;
+        }
+        if (!isCORSWhitelisted(name, value)) {
+          return;
+        }
+        break;
+      }
+      case "response":
+        if (isForbiddenResponse(name)) {
+          return;
+        }
+        break;
+    }
+
+    this.headersList.append(name, value);
+    this._removePrivilegedNoCORSHeaders();
+  }
+
+  set(name, value) {
+    value = value.trim();
+    assertName(name);
+    assertValue(value);
+
+    switch (this.guard) {
+      case "immutable":
+        throw new TypeError("Headers is immutable");
+      case "request":
+        if (isForbidden(name)) {
+          return;
+        }
+        break;
+      case "request-no-cors": {
+        if (!isCORSWhitelisted(name, value)) {
+          return;
+        }
+        break;
+      }
+      case "response":
+        if (isForbiddenResponse(name)) {
+          return;
+        }
+        break;
+    }
+    this.headersList.set(name, value);
+    this._removePrivilegedNoCORSHeaders();
+  }
+
+  delete(name) {
+    assertName(name);
+
+    switch (this.guard) {
+      case "immutable":
+        throw new TypeError("Headers is immutable");
+      case "request":
+        if (isForbidden(name)) {
+          return;
+        }
+        break;
+      case "request-no-cors": {
+        if (
+          !isNoCORSSafelistedRequest(name) &&
+          !isPrivilegedNoCORSRequest(name)
+        ) {
+          return;
+        }
+        break;
+      }
+      case "response":
+        if (isForbiddenResponse(name)) {
+          return;
+        }
+        break;
+    }
+    this.headersList.delete(name);
+    this._removePrivilegedNoCORSHeaders();
+  }
+
+  * [Symbol.iterator]() {
+    for (const header of this.headersList.sortAndCombine()) {
+      yield header;
+    }
+  }
+}
+
+exports.implementation = HeadersImpl;
diff --git a/lib/jsdom/living/fetch/header-list.js b/lib/jsdom/living/fetch/header-list.js
new file mode 100644
index 0000000..b8afa28
--- /dev/null
+++ b/lib/jsdom/living/fetch/header-list.js
@@ -0,0 +1,54 @@
+"use strict";
+
+/**
+ * Provides some utility functions for somewhat efficiently modifying a
+ * collection of headers.
+ *
+ * Note that this class only operates on ByteStrings (which is also why we use
+ * toLowerCase internally).
+ */
+class HeaderList {
+  constructor() {
+    this.headers = new Map();
+  }
+
+  append(name, value) {
+    const existing = this.headers.get(name.toLowerCase());
+    if (existing) {
+      name = existing[0].name;
+      existing.push({ name, value });
+    } else {
+      this.headers.set(name.toLowerCase(), [{ name, value }]);
+    }
+  }
+
+  contains(name) {
+    return this.headers.has(name.toLowerCase());
+  }
+
+  get(name) {
+    name = name.toLowerCase();
+    const values = this.headers.get(name);
+    if (!values) {
+      return null;
+    }
+    return values.map(h => h.value).join(", ");
+  }
+
+  delete(name) {
+    this.headers.delete(name.toLowerCase());
+  }
+
+  set(name, value) {
+    const lowerName = name.toLowerCase();
+    this.headers.delete(lowerName);
+    this.headers.set(lowerName, [{ name, value }]);
+  }
+
+  sortAndCombine() {
+    const names = [...this.headers.keys()].sort();
+    return names.map(n => [n, this.get(n)]);
+  }
+}
+
+module.exports = HeaderList;
diff --git a/lib/jsdom/living/fetch/header-types.js b/lib/jsdom/living/fetch/header-types.js
new file mode 100644
index 0000000..ac3637d
--- /dev/null
+++ b/lib/jsdom/living/fetch/header-types.js
@@ -0,0 +1,103 @@
+"use strict";
+
+const MIMEType = require("whatwg-mimetype");
+
+const PRIVILEGED_NO_CORS_REQUEST = new Set(["range"]);
+function isPrivilegedNoCORSRequest(name) {
+  return PRIVILEGED_NO_CORS_REQUEST.has(name.toLowerCase());
+}
+
+const NO_CORS_SAFELISTED_REQUEST = new Set([
+  `accept`,
+  `accept-language`,
+  `content-language`,
+  `content-type`
+]);
+function isNoCORSSafelistedRequest(name) {
+  return NO_CORS_SAFELISTED_REQUEST.has(name.toLowerCase());
+}
+
+const FORBIDDEN = new Set([
+  `accept-charset`,
+  `accept-encoding`,
+  `access-control-request-headers`,
+  `access-control-request-method`,
+  `connection`,
+  `content-length`,
+  `cookie`,
+  `cookie2`,
+  `date`,
+  `dnt`,
+  `expect`,
+  `host`,
+  `keep-alive`,
+  `origin`,
+  `referer`,
+  `te`,
+  `trailer`,
+  `transfer-encoding`,
+  `upgrade`,
+  `via`
+]);
+function isForbidden(name) {
+  name = name.toLowerCase();
+  return (
+    FORBIDDEN.has(name) || name.startsWith("proxy-") || name.startsWith("sec-")
+  );
+}
+
+const FORBIDDEN_RESPONSE = new Set(["set-cookie", "set-cookie2"]);
+function isForbiddenResponse(name) {
+  return FORBIDDEN_RESPONSE.has(name.toLowerCase());
+}
+
+const CORS_UNSAFE_BYTE = /[\x00-\x08\x0A-\x1F"():<>?@[\\\]{}\x7F]/;
+function isCORSWhitelisted(name, value) {
+  name = name.toLowerCase();
+  switch (name) {
+    case "accept":
+      if (value.match(CORS_UNSAFE_BYTE)) {
+        return false;
+      }
+      break;
+    case "accept-language":
+    case "content-language":
+      if (value.match(/[^\x30-\x39\x41-\x5A\x61-\x7A *,\-.;=]/)) {
+        return false;
+      }
+      break;
+    case "content-type": {
+      if (value.match(CORS_UNSAFE_BYTE)) {
+        return false;
+      }
+      const mimeType = MIMEType.parse(value);
+      if (mimeType === null) {
+        return false;
+      }
+      if (
+        ![
+          "application/x-www-form-urlencoded",
+          "multipart/form-data",
+          "text/plain"
+        ].includes(mimeType.essence)
+      ) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  if (Buffer.from(value).length > 128) {
+    return false;
+  }
+  return true;
+}
+
+module.exports = {
+  isPrivilegedNoCORSRequest,
+  isNoCORSSafelistedRequest,
+  isForbidden,
+  isForbiddenResponse,
+  isCORSWhitelisted
+};
diff --git a/lib/jsdom/living/file-api/Blob-impl.js b/lib/jsdom/living/file-api/Blob-impl.js
new file mode 100644
index 0000000..ec49694
--- /dev/null
+++ b/lib/jsdom/living/file-api/Blob-impl.js
@@ -0,0 +1,95 @@
+"use strict";
+const Blob = require("../generated/Blob");
+const { isArrayBuffer } = require("../generated/utils");
+
+function convertLineEndingsToNative(s) {
+  // jsdom always pretends to be *nix, for consistency.
+  // See also https://github.com/jsdom/jsdom/issues/2396.
+  return s.replace(/\r\n|\r|\n/g, "\n");
+}
+
+exports.implementation = class BlobImpl {
+  constructor(globalObject, args) {
+    const parts = args[0];
+    const properties = args[1];
+
+    const buffers = [];
+
+    if (parts !== undefined) {
+      for (const part of parts) {
+        let buffer;
+        if (isArrayBuffer(part)) {
+          buffer = Buffer.from(part);
+        } else if (ArrayBuffer.isView(part)) {
+          buffer = Buffer.from(part.buffer, part.byteOffset, part.byteLength);
+        } else if (Blob.isImpl(part)) {
+          buffer = part._buffer;
+        } else {
+          let s = part;
+          if (properties.endings === "native") {
+            s = convertLineEndingsToNative(part);
+          }
+          buffer = Buffer.from(s);
+        }
+        buffers.push(buffer);
+      }
+    }
+
+    this._buffer = Buffer.concat(buffers);
+    this._globalObject = globalObject;
+
+    this.type = properties.type;
+    if (/[^\u0020-\u007E]/.test(this.type)) {
+      this.type = "";
+    } else {
+      this.type = this.type.toLowerCase();
+    }
+  }
+
+  get size() {
+    return this._buffer.length;
+  }
+
+  slice(start, end, contentType) {
+    const { size } = this;
+
+    let relativeStart;
+    let relativeEnd;
+    let relativeContentType;
+
+    if (start === undefined) {
+      relativeStart = 0;
+    } else if (start < 0) {
+      relativeStart = Math.max(size + start, 0);
+    } else {
+      relativeStart = Math.min(start, size);
+    }
+    if (end === undefined) {
+      relativeEnd = size;
+    } else if (end < 0) {
+      relativeEnd = Math.max(size + end, 0);
+    } else {
+      relativeEnd = Math.min(end, size);
+    }
+
+    if (contentType === undefined) {
+      relativeContentType = "";
+    } else {
+      // sanitization (lower case and invalid char check) is done in the
+      // constructor
+      relativeContentType = contentType;
+    }
+
+    const span = Math.max(relativeEnd - relativeStart, 0);
+
+    const buffer = this._buffer;
+    const slicedBuffer = buffer.slice(
+      relativeStart,
+      relativeStart + span
+    );
+
+    const blob = Blob.createImpl(this._globalObject, [[], { type: relativeContentType }], {});
+    blob._buffer = slicedBuffer;
+    return blob;
+  }
+};
diff --git a/lib/jsdom/living/file-api/File-impl.js b/lib/jsdom/living/file-api/File-impl.js
new file mode 100644
index 0000000..c33c08f
--- /dev/null
+++ b/lib/jsdom/living/file-api/File-impl.js
@@ -0,0 +1,15 @@
+"use strict";
+
+const BlobImpl = require("./Blob-impl").implementation;
+
+exports.implementation = class FileImpl extends BlobImpl {
+  constructor(globalObject, args, privateData) {
+    const fileBits = args[0];
+    const fileName = args[1];
+    const options = args[2];
+    super(globalObject, [fileBits, options], privateData);
+
+    this.name = fileName.replace(/\//g, ":");
+    this.lastModified = "lastModified" in options ? options.lastModified : Date.now();
+  }
+};
diff --git a/lib/jsdom/living/file-api/FileList-impl.js b/lib/jsdom/living/file-api/FileList-impl.js
new file mode 100644
index 0000000..04eedcb
--- /dev/null
+++ b/lib/jsdom/living/file-api/FileList-impl.js
@@ -0,0 +1,15 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+
+exports.implementation = class FileListImpl extends Array {
+  constructor() {
+    super(0);
+  }
+  item(index) {
+    return this[index] || null;
+  }
+  get [idlUtils.supportedPropertyIndices]() {
+    return this.keys();
+  }
+};
diff --git a/lib/jsdom/living/file-api/FileReader-impl.js b/lib/jsdom/living/file-api/FileReader-impl.js
new file mode 100644
index 0000000..bd58025
--- /dev/null
+++ b/lib/jsdom/living/file-api/FileReader-impl.js
@@ -0,0 +1,130 @@
+"use strict";
+
+const whatwgEncoding = require("whatwg-encoding");
+const MIMEType = require("whatwg-mimetype");
+const DOMException = require("domexception/webidl2js-wrapper");
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+const ProgressEvent = require("../generated/ProgressEvent");
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+const { copyToArrayBufferInNewRealm } = require("../helpers/binary-data");
+
+const READY_STATES = Object.freeze({
+  EMPTY: 0,
+  LOADING: 1,
+  DONE: 2
+});
+
+const events = ["loadstart", "progress", "load", "abort", "error", "loadend"];
+
+class FileReaderImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.error = null;
+    this.readyState = READY_STATES.EMPTY;
+    this.result = null;
+
+    this._globalObject = globalObject;
+    this._ownerDocument = globalObject.document;
+    this._terminated = false;
+  }
+
+  readAsArrayBuffer(file) {
+    this._readFile(file, "buffer");
+  }
+  readAsBinaryString(file) {
+    this._readFile(file, "binaryString");
+  }
+  readAsDataURL(file) {
+    this._readFile(file, "dataURL");
+  }
+  readAsText(file, encoding) {
+    this._readFile(file, "text", whatwgEncoding.labelToName(encoding) || "UTF-8");
+  }
+
+  abort() {
+    if (this.readyState === READY_STATES.EMPTY || this.readyState === READY_STATES.DONE) {
+      this.result = null;
+      return;
+    }
+
+    if (this.readyState === READY_STATES.LOADING) {
+      this.readyState = READY_STATES.DONE;
+      this.result = null;
+    }
+
+    this._terminated = true;
+    this._fireProgressEvent("abort");
+    this._fireProgressEvent("loadend");
+  }
+
+  _fireProgressEvent(name, props) {
+    fireAnEvent(name, this, ProgressEvent, props);
+  }
+
+  _readFile(file, format, encoding) {
+    if (this.readyState === READY_STATES.LOADING) {
+      throw DOMException.create(this._globalObject, [
+        "The object is in an invalid state.",
+        "InvalidStateError"
+      ]);
+    }
+
+    this.readyState = READY_STATES.LOADING;
+
+    setImmediate(() => {
+      if (this._terminated) {
+        this._terminated = false;
+        return;
+      }
+
+      this._fireProgressEvent("loadstart");
+
+      let data = file._buffer;
+      if (!data) {
+        data = Buffer.alloc(0);
+      }
+      this._fireProgressEvent("progress", {
+        lengthComputable: !isNaN(file.size),
+        total: file.size,
+        loaded: data.length
+      });
+
+      setImmediate(() => {
+        if (this._terminated) {
+          this._terminated = false;
+          return;
+        }
+
+        switch (format) {
+          default:
+          case "buffer": {
+            this.result = copyToArrayBufferInNewRealm(data, this._globalObject);
+            break;
+          }
+          case "binaryString": {
+            this.result = data.toString("binary");
+            break;
+          }
+          case "dataURL": {
+            // Spec seems very unclear here; see https://github.com/w3c/FileAPI/issues/104.
+            const contentType = MIMEType.parse(file.type) || "application/octet-stream";
+            this.result = `data:${contentType};base64,${data.toString("base64")}`;
+            break;
+          }
+          case "text": {
+            this.result = whatwgEncoding.decode(data, encoding);
+            break;
+          }
+        }
+        this.readyState = READY_STATES.DONE;
+        this._fireProgressEvent("load");
+        this._fireProgressEvent("loadend");
+      });
+    });
+  }
+}
+setupForSimpleEventAccessors(FileReaderImpl.prototype, events);
+
+exports.implementation = FileReaderImpl;
diff --git a/lib/jsdom/living/generated/AbortController.js b/lib/jsdom/living/generated/AbortController.js
new file mode 100644
index 0000000..4aba3ad
--- /dev/null
+++ b/lib/jsdom/living/generated/AbortController.js
@@ -0,0 +1,128 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "AbortController";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'AbortController'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["AbortController"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor AbortController is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class AbortController {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    abort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].abort();
+    }
+
+    get signal() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "signal", () => {
+        return utils.tryWrapperForImpl(this[impl]["signal"]);
+      });
+    }
+  }
+  Object.defineProperties(AbortController.prototype, {
+    abort: { enumerable: true },
+    signal: { enumerable: true },
+    [Symbol.toStringTag]: { value: "AbortController", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = AbortController;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: AbortController
+  });
+};
+
+const Impl = require("../aborting/AbortController-impl.js");
diff --git a/lib/jsdom/living/generated/AbortSignal.js b/lib/jsdom/living/generated/AbortSignal.js
new file mode 100644
index 0000000..6957c63
--- /dev/null
+++ b/lib/jsdom/living/generated/AbortSignal.js
@@ -0,0 +1,142 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "AbortSignal";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'AbortSignal'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["AbortSignal"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor AbortSignal is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  EventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.EventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate AbortSignal before EventTarget");
+  }
+  class AbortSignal extends globalObject.EventTarget {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get aborted() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["aborted"];
+    }
+
+    get onabort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onabort"]);
+    }
+
+    set onabort(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onabort"] = V;
+    }
+  }
+  Object.defineProperties(AbortSignal.prototype, {
+    aborted: { enumerable: true },
+    onabort: { enumerable: true },
+    [Symbol.toStringTag]: { value: "AbortSignal", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = AbortSignal;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: AbortSignal
+  });
+};
+
+const Impl = require("../aborting/AbortSignal-impl.js");
diff --git a/lib/jsdom/living/generated/AbstractRange.js b/lib/jsdom/living/generated/AbstractRange.js
new file mode 100644
index 0000000..588f11a
--- /dev/null
+++ b/lib/jsdom/living/generated/AbstractRange.js
@@ -0,0 +1,153 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "AbstractRange";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'AbstractRange'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["AbstractRange"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor AbstractRange is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class AbstractRange {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get startContainer() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["startContainer"]);
+    }
+
+    get startOffset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["startOffset"];
+    }
+
+    get endContainer() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["endContainer"]);
+    }
+
+    get endOffset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["endOffset"];
+    }
+
+    get collapsed() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["collapsed"];
+    }
+  }
+  Object.defineProperties(AbstractRange.prototype, {
+    startContainer: { enumerable: true },
+    startOffset: { enumerable: true },
+    endContainer: { enumerable: true },
+    endOffset: { enumerable: true },
+    collapsed: { enumerable: true },
+    [Symbol.toStringTag]: { value: "AbstractRange", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = AbstractRange;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: AbstractRange
+  });
+};
+
+const Impl = require("../range/AbstractRange-impl.js");
diff --git a/lib/jsdom/living/generated/AddEventListenerOptions.js b/lib/jsdom/living/generated/AddEventListenerOptions.js
new file mode 100644
index 0000000..9a614e2
--- /dev/null
+++ b/lib/jsdom/living/generated/AddEventListenerOptions.js
@@ -0,0 +1,44 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventListenerOptions = require("./EventListenerOptions.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventListenerOptions.convertInherit(obj, ret, { context });
+
+  {
+    const key = "once";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member once that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "passive";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member passive that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/AssignedNodesOptions.js b/lib/jsdom/living/generated/AssignedNodesOptions.js
new file mode 100644
index 0000000..5c43264
--- /dev/null
+++ b/lib/jsdom/living/generated/AssignedNodesOptions.js
@@ -0,0 +1,28 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "flatten";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member flatten that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Attr.js b/lib/jsdom/living/generated/Attr.js
new file mode 100644
index 0000000..b36b889
--- /dev/null
+++ b/lib/jsdom/living/generated/Attr.js
@@ -0,0 +1,199 @@
+"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 impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Node = require("./Node.js");
+
+const interfaceName = "Attr";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Attr'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Attr"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Attr is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Node._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Node === undefined) {
+    throw new Error("Internal error: attempting to evaluate Attr before Node");
+  }
+  class Attr extends globalObject.Node {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get namespaceURI() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["namespaceURI"];
+    }
+
+    get prefix() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["prefix"];
+    }
+
+    get localName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["localName"];
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["name"];
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, { context: "Failed to set the 'value' property on 'Attr': The provided value" });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get ownerElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ownerElement"]);
+    }
+
+    get specified() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["specified"];
+    }
+  }
+  Object.defineProperties(Attr.prototype, {
+    namespaceURI: { enumerable: true },
+    prefix: { enumerable: true },
+    localName: { enumerable: true },
+    name: { enumerable: true },
+    value: { enumerable: true },
+    ownerElement: { enumerable: true },
+    specified: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Attr", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Attr;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Attr
+  });
+};
+
+const Impl = require("../attributes/Attr-impl.js");
diff --git a/lib/jsdom/living/generated/BarProp.js b/lib/jsdom/living/generated/BarProp.js
new file mode 100644
index 0000000..76b46a3
--- /dev/null
+++ b/lib/jsdom/living/generated/BarProp.js
@@ -0,0 +1,117 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "BarProp";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'BarProp'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["BarProp"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor BarProp is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class BarProp {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get visible() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["visible"];
+    }
+  }
+  Object.defineProperties(BarProp.prototype, {
+    visible: { enumerable: true },
+    [Symbol.toStringTag]: { value: "BarProp", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = BarProp;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: BarProp
+  });
+};
+
+const Impl = require("../window/BarProp-impl.js");
diff --git a/lib/jsdom/living/generated/BinaryType.js b/lib/jsdom/living/generated/BinaryType.js
new file mode 100644
index 0000000..b0a05e6
--- /dev/null
+++ b/lib/jsdom/living/generated/BinaryType.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["blob", "arraybuffer"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for BinaryType`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/Blob.js b/lib/jsdom/living/generated/Blob.js
new file mode 100644
index 0000000..63e6e3a
--- /dev/null
+++ b/lib/jsdom/living/generated/Blob.js
@@ -0,0 +1,194 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertBlobPropertyBag = require("./BlobPropertyBag.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Blob";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Blob'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Blob"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Blob is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Blob {
+    constructor() {
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          if (!utils.isObject(curArg)) {
+            throw new TypeError("Failed to construct 'Blob': parameter 1" + " is not an iterable object.");
+          } else {
+            const V = [];
+            const tmp = curArg;
+            for (let nextItem of tmp) {
+              if (module.exports.is(nextItem)) {
+                nextItem = utils.implForWrapper(nextItem);
+              } else if (utils.isArrayBuffer(nextItem)) {
+              } else if (ArrayBuffer.isView(nextItem)) {
+              } else {
+                nextItem = conversions["USVString"](nextItem, {
+                  context: "Failed to construct 'Blob': parameter 1" + "'s element"
+                });
+              }
+              V.push(nextItem);
+            }
+            curArg = V;
+          }
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertBlobPropertyBag(curArg, { context: "Failed to construct 'Blob': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    slice() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long long"](curArg, {
+            context: "Failed to execute 'slice' on 'Blob': parameter 1",
+            clamp: true
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["long long"](curArg, {
+            context: "Failed to execute 'slice' on 'Blob': parameter 2",
+            clamp: true
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'slice' on 'Blob': parameter 3" });
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].slice(...args));
+    }
+
+    get size() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["size"];
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+  }
+  Object.defineProperties(Blob.prototype, {
+    slice: { enumerable: true },
+    size: { enumerable: true },
+    type: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Blob", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Blob;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Blob
+  });
+};
+
+const Impl = require("../file-api/Blob-impl.js");
diff --git a/lib/jsdom/living/generated/BlobPropertyBag.js b/lib/jsdom/living/generated/BlobPropertyBag.js
new file mode 100644
index 0000000..9222496
--- /dev/null
+++ b/lib/jsdom/living/generated/BlobPropertyBag.js
@@ -0,0 +1,42 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertEndingType = require("./EndingType.js").convert;
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "endings";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = convertEndingType(value, { context: context + " has member endings that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "transparent";
+    }
+  }
+
+  {
+    const key = "type";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member type that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/CDATASection.js b/lib/jsdom/living/generated/CDATASection.js
new file mode 100644
index 0000000..5ea98bc
--- /dev/null
+++ b/lib/jsdom/living/generated/CDATASection.js
@@ -0,0 +1,114 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Text = require("./Text.js");
+
+const interfaceName = "CDATASection";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'CDATASection'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["CDATASection"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor CDATASection is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Text._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Text === undefined) {
+    throw new Error("Internal error: attempting to evaluate CDATASection before Text");
+  }
+  class CDATASection extends globalObject.Text {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(CDATASection.prototype, {
+    [Symbol.toStringTag]: { value: "CDATASection", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = CDATASection;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: CDATASection
+  });
+};
+
+const Impl = require("../nodes/CDATASection-impl.js");
diff --git a/lib/jsdom/living/generated/CanPlayTypeResult.js b/lib/jsdom/living/generated/CanPlayTypeResult.js
new file mode 100644
index 0000000..afe5692
--- /dev/null
+++ b/lib/jsdom/living/generated/CanPlayTypeResult.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["", "maybe", "probably"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for CanPlayTypeResult`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/CharacterData.js b/lib/jsdom/living/generated/CharacterData.js
new file mode 100644
index 0000000..9d478c1
--- /dev/null
+++ b/lib/jsdom/living/generated/CharacterData.js
@@ -0,0 +1,414 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isNode = require("./Node.js").is;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Node = require("./Node.js");
+
+const interfaceName = "CharacterData";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'CharacterData'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["CharacterData"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor CharacterData is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Node._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Node === undefined) {
+    throw new Error("Internal error: attempting to evaluate CharacterData before Node");
+  }
+  class CharacterData extends globalObject.Node {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    substringData(offset, count) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'substringData' on 'CharacterData': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'substringData' on 'CharacterData': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'substringData' on 'CharacterData': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].substringData(...args);
+    }
+
+    appendData(data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'appendData' on 'CharacterData': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'appendData' on 'CharacterData': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].appendData(...args);
+    }
+
+    insertData(offset, data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'insertData' on 'CharacterData': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'insertData' on 'CharacterData': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertData' on 'CharacterData': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].insertData(...args);
+    }
+
+    deleteData(offset, count) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'deleteData' on 'CharacterData': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'deleteData' on 'CharacterData': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'deleteData' on 'CharacterData': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].deleteData(...args);
+    }
+
+    replaceData(offset, count, data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 3) {
+        throw new TypeError(
+          "Failed to execute 'replaceData' on 'CharacterData': 3 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'replaceData' on 'CharacterData': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'replaceData' on 'CharacterData': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'replaceData' on 'CharacterData': parameter 3"
+        });
+        args.push(curArg);
+      }
+      return this[impl].replaceData(...args);
+    }
+
+    before() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'before' on 'CharacterData': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].before(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    after() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'after' on 'CharacterData': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].after(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    replaceWith() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'replaceWith' on 'CharacterData': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].replaceWith(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    remove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].remove();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get data() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["data"];
+    }
+
+    set data(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'data' property on 'CharacterData': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      this[impl]["data"] = V;
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+
+    get previousElementSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["previousElementSibling"]);
+    }
+
+    get nextElementSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["nextElementSibling"]);
+    }
+  }
+  Object.defineProperties(CharacterData.prototype, {
+    substringData: { enumerable: true },
+    appendData: { enumerable: true },
+    insertData: { enumerable: true },
+    deleteData: { enumerable: true },
+    replaceData: { enumerable: true },
+    before: { enumerable: true },
+    after: { enumerable: true },
+    replaceWith: { enumerable: true },
+    remove: { enumerable: true },
+    data: { enumerable: true },
+    length: { enumerable: true },
+    previousElementSibling: { enumerable: true },
+    nextElementSibling: { enumerable: true },
+    [Symbol.toStringTag]: { value: "CharacterData", configurable: true },
+    [Symbol.unscopables]: {
+      value: { before: true, after: true, replaceWith: true, remove: true, __proto__: null },
+      configurable: true
+    }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = CharacterData;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: CharacterData
+  });
+};
+
+const Impl = require("../nodes/CharacterData-impl.js");
diff --git a/lib/jsdom/living/generated/CloseEvent.js b/lib/jsdom/living/generated/CloseEvent.js
new file mode 100644
index 0000000..0c655a9
--- /dev/null
+++ b/lib/jsdom/living/generated/CloseEvent.js
@@ -0,0 +1,158 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertCloseEventInit = require("./CloseEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "CloseEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'CloseEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["CloseEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor CloseEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate CloseEvent before Event");
+  }
+  class CloseEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'CloseEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'CloseEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertCloseEventInit(curArg, { context: "Failed to construct 'CloseEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get wasClean() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["wasClean"];
+    }
+
+    get code() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["code"];
+    }
+
+    get reason() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["reason"];
+    }
+  }
+  Object.defineProperties(CloseEvent.prototype, {
+    wasClean: { enumerable: true },
+    code: { enumerable: true },
+    reason: { enumerable: true },
+    [Symbol.toStringTag]: { value: "CloseEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = CloseEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: CloseEvent
+  });
+};
+
+const Impl = require("../events/CloseEvent-impl.js");
diff --git a/lib/jsdom/living/generated/CloseEventInit.js b/lib/jsdom/living/generated/CloseEventInit.js
new file mode 100644
index 0000000..aeff94b
--- /dev/null
+++ b/lib/jsdom/living/generated/CloseEventInit.js
@@ -0,0 +1,56 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "code";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned short"](value, { context: context + " has member code that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "reason";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["USVString"](value, { context: context + " has member reason that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "wasClean";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member wasClean that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Comment.js b/lib/jsdom/living/generated/Comment.js
new file mode 100644
index 0000000..7ce33d9
--- /dev/null
+++ b/lib/jsdom/living/generated/Comment.js
@@ -0,0 +1,122 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const CharacterData = require("./CharacterData.js");
+
+const interfaceName = "Comment";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Comment'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Comment"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Comment is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  CharacterData._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.CharacterData === undefined) {
+    throw new Error("Internal error: attempting to evaluate Comment before CharacterData");
+  }
+  class Comment extends globalObject.CharacterData {
+    constructor() {
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'Comment': parameter 1" });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+  }
+  Object.defineProperties(Comment.prototype, { [Symbol.toStringTag]: { value: "Comment", configurable: true } });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Comment;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Comment
+  });
+};
+
+const Impl = require("../nodes/Comment-impl.js");
diff --git a/lib/jsdom/living/generated/CompositionEvent.js b/lib/jsdom/living/generated/CompositionEvent.js
new file mode 100644
index 0000000..8ad06a0
--- /dev/null
+++ b/lib/jsdom/living/generated/CompositionEvent.js
@@ -0,0 +1,212 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertCompositionEventInit = require("./CompositionEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const UIEvent = require("./UIEvent.js");
+
+const interfaceName = "CompositionEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'CompositionEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["CompositionEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor CompositionEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  UIEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.UIEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate CompositionEvent before UIEvent");
+  }
+  class CompositionEvent extends globalObject.UIEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'CompositionEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'CompositionEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertCompositionEventInit(curArg, {
+          context: "Failed to construct 'CompositionEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    initCompositionEvent(typeArg) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initCompositionEvent' on 'CompositionEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initCompositionEvent' on 'CompositionEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initCompositionEvent' on 'CompositionEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initCompositionEvent' on 'CompositionEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[4];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'initCompositionEvent' on 'CompositionEvent': parameter 5"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      return this[impl].initCompositionEvent(...args);
+    }
+
+    get data() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["data"];
+    }
+  }
+  Object.defineProperties(CompositionEvent.prototype, {
+    initCompositionEvent: { enumerable: true },
+    data: { enumerable: true },
+    [Symbol.toStringTag]: { value: "CompositionEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = CompositionEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: CompositionEvent
+  });
+};
+
+const Impl = require("../events/CompositionEvent-impl.js");
diff --git a/lib/jsdom/living/generated/CompositionEventInit.js b/lib/jsdom/living/generated/CompositionEventInit.js
new file mode 100644
index 0000000..49ced25
--- /dev/null
+++ b/lib/jsdom/living/generated/CompositionEventInit.js
@@ -0,0 +1,32 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const UIEventInit = require("./UIEventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  UIEventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "data";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member data that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/CustomElementRegistry.js b/lib/jsdom/living/generated/CustomElementRegistry.js
new file mode 100644
index 0000000..80feb8b
--- /dev/null
+++ b/lib/jsdom/living/generated/CustomElementRegistry.js
@@ -0,0 +1,230 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertElementDefinitionOptions = require("./ElementDefinitionOptions.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const convertNode = require("./Node.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "CustomElementRegistry";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'CustomElementRegistry'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["CustomElementRegistry"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor CustomElementRegistry is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class CustomElementRegistry {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    define(name, constructor) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'define' on 'CustomElementRegistry': 2 arguments required, but only " +
+          arguments.length +
+          " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'define' on 'CustomElementRegistry': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = utils.tryImplForWrapper(curArg);
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = convertElementDefinitionOptions(curArg, {
+          context: "Failed to execute 'define' on 'CustomElementRegistry': parameter 3"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].define(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'get' on 'CustomElementRegistry': 1 argument required, but only " +
+          arguments.length +
+          " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'get' on 'CustomElementRegistry': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].get(...args);
+    }
+
+    whenDefined(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'whenDefined' on 'CustomElementRegistry': 1 argument required, but only " +
+          arguments.length +
+          " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'whenDefined' on 'CustomElementRegistry': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].whenDefined(...args));
+    }
+
+    upgrade(root) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'upgrade' on 'CustomElementRegistry': 1 argument required, but only " +
+          arguments.length +
+          " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, {
+          context: "Failed to execute 'upgrade' on 'CustomElementRegistry': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].upgrade(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(CustomElementRegistry.prototype, {
+    define: { enumerable: true },
+    get: { enumerable: true },
+    whenDefined: { enumerable: true },
+    upgrade: { enumerable: true },
+    [Symbol.toStringTag]: { value: "CustomElementRegistry", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = CustomElementRegistry;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: CustomElementRegistry
+  });
+};
+
+const Impl = require("../custom-elements/CustomElementRegistry-impl.js");
diff --git a/lib/jsdom/living/generated/CustomEvent.js b/lib/jsdom/living/generated/CustomEvent.js
new file mode 100644
index 0000000..6a0f15a
--- /dev/null
+++ b/lib/jsdom/living/generated/CustomEvent.js
@@ -0,0 +1,197 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertCustomEventInit = require("./CustomEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "CustomEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'CustomEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["CustomEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor CustomEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate CustomEvent before Event");
+  }
+  class CustomEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'CustomEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'CustomEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertCustomEventInit(curArg, { context: "Failed to construct 'CustomEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    initCustomEvent(type) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initCustomEvent' on 'CustomEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initCustomEvent' on 'CustomEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initCustomEvent' on 'CustomEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initCustomEvent' on 'CustomEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          curArg = conversions["any"](curArg, {
+            context: "Failed to execute 'initCustomEvent' on 'CustomEvent': parameter 4"
+          });
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return this[impl].initCustomEvent(...args);
+    }
+
+    get detail() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["detail"];
+    }
+  }
+  Object.defineProperties(CustomEvent.prototype, {
+    initCustomEvent: { enumerable: true },
+    detail: { enumerable: true },
+    [Symbol.toStringTag]: { value: "CustomEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = CustomEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: CustomEvent
+  });
+};
+
+const Impl = require("../events/CustomEvent-impl.js");
diff --git a/lib/jsdom/living/generated/CustomEventInit.js b/lib/jsdom/living/generated/CustomEventInit.js
new file mode 100644
index 0000000..dbc62d8
--- /dev/null
+++ b/lib/jsdom/living/generated/CustomEventInit.js
@@ -0,0 +1,32 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "detail";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["any"](value, { context: context + " has member detail that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/DOMImplementation.js b/lib/jsdom/living/generated/DOMImplementation.js
new file mode 100644
index 0000000..063e33c
--- /dev/null
+++ b/lib/jsdom/living/generated/DOMImplementation.js
@@ -0,0 +1,225 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertDocumentType = require("./DocumentType.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "DOMImplementation";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'DOMImplementation'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["DOMImplementation"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor DOMImplementation is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class DOMImplementation {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    createDocumentType(qualifiedName, publicId, systemId) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 3) {
+        throw new TypeError(
+          "Failed to execute 'createDocumentType' on 'DOMImplementation': 3 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createDocumentType' on 'DOMImplementation': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createDocumentType' on 'DOMImplementation': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createDocumentType' on 'DOMImplementation': parameter 3"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createDocumentType(...args));
+    }
+
+    createDocument(namespace, qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'createDocument' on 'DOMImplementation': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'createDocument' on 'DOMImplementation': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createDocument' on 'DOMImplementation': parameter 2",
+          treatNullAsEmptyString: true
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = convertDocumentType(curArg, {
+              context: "Failed to execute 'createDocument' on 'DOMImplementation': parameter 3"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createDocument(...args));
+    }
+
+    createHTMLDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'createHTMLDocument' on 'DOMImplementation': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createHTMLDocument(...args));
+    }
+
+    hasFeature() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].hasFeature();
+    }
+  }
+  Object.defineProperties(DOMImplementation.prototype, {
+    createDocumentType: { enumerable: true },
+    createDocument: { enumerable: true },
+    createHTMLDocument: { enumerable: true },
+    hasFeature: { enumerable: true },
+    [Symbol.toStringTag]: { value: "DOMImplementation", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = DOMImplementation;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DOMImplementation
+  });
+};
+
+const Impl = require("../nodes/DOMImplementation-impl.js");
diff --git a/lib/jsdom/living/generated/DOMParser.js b/lib/jsdom/living/generated/DOMParser.js
new file mode 100644
index 0000000..289d1ba
--- /dev/null
+++ b/lib/jsdom/living/generated/DOMParser.js
@@ -0,0 +1,140 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertSupportedType = require("./SupportedType.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "DOMParser";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'DOMParser'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["DOMParser"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor DOMParser is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class DOMParser {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    parseFromString(str, type) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'parseFromString' on 'DOMParser': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'parseFromString' on 'DOMParser': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertSupportedType(curArg, {
+          context: "Failed to execute 'parseFromString' on 'DOMParser': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].parseFromString(...args));
+    }
+  }
+  Object.defineProperties(DOMParser.prototype, {
+    parseFromString: { enumerable: true },
+    [Symbol.toStringTag]: { value: "DOMParser", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = DOMParser;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DOMParser
+  });
+};
+
+const Impl = require("../domparsing/DOMParser-impl.js");
diff --git a/lib/jsdom/living/generated/DOMStringMap.js b/lib/jsdom/living/generated/DOMStringMap.js
new file mode 100644
index 0000000..6144967
--- /dev/null
+++ b/lib/jsdom/living/generated/DOMStringMap.js
@@ -0,0 +1,317 @@
+"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 impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "DOMStringMap";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'DOMStringMap'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["DOMStringMap"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor DOMStringMap is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  {
+    let proxyHandler = proxyHandlerCache.get(globalObject);
+    if (proxyHandler === undefined) {
+      proxyHandler = new ProxyHandler(globalObject);
+      proxyHandlerCache.set(globalObject, proxyHandler);
+    }
+    obj = new Proxy(obj, proxyHandler);
+  }
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class DOMStringMap {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(DOMStringMap.prototype, {
+    [Symbol.toStringTag]: { value: "DOMStringMap", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = DOMStringMap;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DOMStringMap
+  });
+};
+
+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[impl][utils.supportedPropertyNames]) {
+      if (!utils.hasOwn(target, key)) {
+        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[impl][utils.namedGet](P);
+
+    if (namedValue !== undefined && !utils.hasOwn(target, P) && !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);
+    }
+    if (target === receiver) {
+      const globalObject = this._globalObject;
+
+      if (typeof P === "string" && !utils.isArrayIndexPropName(P)) {
+        let namedValue = V;
+
+        namedValue = conversions["DOMString"](namedValue, {
+          context: "Failed to set the '" + P + "' property on 'DOMStringMap': The provided value"
+        });
+
+        ceReactionsPreSteps_helpers_custom_elements(globalObject);
+        try {
+          const creating = !(target[impl][utils.namedGet](P) !== undefined);
+          if (creating) {
+            target[impl][utils.namedSetNew](P, namedValue);
+          } else {
+            target[impl][utils.namedSetExisting](P, namedValue);
+          }
+        } finally {
+          ceReactionsPostSteps_helpers_custom_elements(globalObject);
+        }
+
+        return true;
+      }
+    }
+    let ownDesc;
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  }
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (desc.get || desc.set) {
+      return false;
+    }
+
+    let namedValue = desc.value;
+
+    namedValue = conversions["DOMString"](namedValue, {
+      context: "Failed to set the '" + P + "' property on 'DOMStringMap': The provided value"
+    });
+
+    ceReactionsPreSteps_helpers_custom_elements(globalObject);
+    try {
+      const creating = !(target[impl][utils.namedGet](P) !== undefined);
+      if (creating) {
+        target[impl][utils.namedSetNew](P, namedValue);
+      } else {
+        target[impl][utils.namedSetExisting](P, namedValue);
+      }
+    } finally {
+      ceReactionsPostSteps_helpers_custom_elements(globalObject);
+    }
+
+    return true;
+  }
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (target[impl][utils.namedGet](P) !== undefined && !utils.hasOwn(target, P)) {
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        target[impl][utils.namedDelete](P);
+        return true;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../nodes/DOMStringMap-impl.js");
diff --git a/lib/jsdom/living/generated/DOMTokenList.js b/lib/jsdom/living/generated/DOMTokenList.js
new file mode 100644
index 0000000..adb4dbc
--- /dev/null
+++ b/lib/jsdom/living/generated/DOMTokenList.js
@@ -0,0 +1,515 @@
+"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 impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "DOMTokenList";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'DOMTokenList'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["DOMTokenList"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor DOMTokenList is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class DOMTokenList {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'DOMTokenList': 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 'DOMTokenList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].item(...args);
+    }
+
+    contains(token) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'contains' on 'DOMTokenList': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'contains' on 'DOMTokenList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].contains(...args);
+    }
+
+    add() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'add' on 'DOMTokenList': parameter " + (i + 1)
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].add(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    remove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'remove' on 'DOMTokenList': parameter " + (i + 1)
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].remove(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    toggle(token) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'toggle' on 'DOMTokenList': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'toggle' on 'DOMTokenList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'toggle' on 'DOMTokenList': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].toggle(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    replace(token, newToken) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'replace' on 'DOMTokenList': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'replace' on 'DOMTokenList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'replace' on 'DOMTokenList': parameter 2"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].replace(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    supports(token) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'supports' on 'DOMTokenList': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'supports' on 'DOMTokenList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].supports(...args);
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'DOMTokenList': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    toString() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(DOMTokenList.prototype, {
+    item: { enumerable: true },
+    contains: { enumerable: true },
+    add: { enumerable: true },
+    remove: { enumerable: true },
+    toggle: { enumerable: true },
+    replace: { enumerable: true },
+    supports: { enumerable: true },
+    length: { enumerable: true },
+    value: { enumerable: true },
+    toString: { enumerable: true },
+    [Symbol.toStringTag]: { value: "DOMTokenList", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true },
+    keys: { value: Array.prototype.keys, configurable: true, enumerable: true, writable: true },
+    values: { value: Array.prototype[Symbol.iterator], configurable: true, enumerable: true, writable: true },
+    entries: { value: Array.prototype.entries, configurable: true, enumerable: true, writable: true },
+    forEach: { value: Array.prototype.forEach, configurable: true, enumerable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = DOMTokenList;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DOMTokenList
+  });
+};
+
+const proxyHandler = {
+  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[impl][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[impl].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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../nodes/DOMTokenList-impl.js");
diff --git a/lib/jsdom/living/generated/Document.js b/lib/jsdom/living/generated/Document.js
new file mode 100644
index 0000000..a27a419
--- /dev/null
+++ b/lib/jsdom/living/generated/Document.js
@@ -0,0 +1,2589 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertElementCreationOptions = require("./ElementCreationOptions.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const convertNode = require("./Node.js").convert;
+const isNode = require("./Node.js").is;
+const convertHTMLElement = require("./HTMLElement.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Node = require("./Node.js");
+
+const interfaceName = "Document";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Document'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Document"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Document is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Node._internalSetup(obj);
+
+  Object.defineProperties(
+    obj,
+    Object.getOwnPropertyDescriptors({
+      get location() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return utils.tryWrapperForImpl(obj[impl]["location"]);
+      },
+      set location(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        this.location.href = V;
+      }
+    })
+  );
+
+  Object.defineProperties(obj, { location: { configurable: false } });
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Node === undefined) {
+    throw new Error("Internal error: attempting to evaluate Document before Node");
+  }
+  class Document extends globalObject.Node {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    getElementsByTagName(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByTagName' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByTagName' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByTagName(...args));
+    }
+
+    getElementsByTagNameNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByTagNameNS' on 'Document': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'getElementsByTagNameNS' on 'Document': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByTagNameNS' on 'Document': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByTagNameNS(...args));
+    }
+
+    getElementsByClassName(classNames) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByClassName' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByClassName' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByClassName(...args));
+    }
+
+    createElement(localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createElement' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createElement' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = convertElementCreationOptions(curArg, {
+              context: "Failed to execute 'createElement' on 'Document': parameter 2"
+            });
+          } else if (utils.isObject(curArg)) {
+            curArg = convertElementCreationOptions(curArg, {
+              context: "Failed to execute 'createElement' on 'Document': parameter 2" + " dictionary"
+            });
+          } else {
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'createElement' on 'Document': parameter 2"
+            });
+          }
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].createElement(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    createElementNS(namespace, qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'createElementNS' on 'Document': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'createElementNS' on 'Document': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createElementNS' on 'Document': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = convertElementCreationOptions(curArg, {
+              context: "Failed to execute 'createElementNS' on 'Document': parameter 3"
+            });
+          } else if (utils.isObject(curArg)) {
+            curArg = convertElementCreationOptions(curArg, {
+              context: "Failed to execute 'createElementNS' on 'Document': parameter 3" + " dictionary"
+            });
+          } else {
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'createElementNS' on 'Document': parameter 3"
+            });
+          }
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].createElementNS(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    createDocumentFragment() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createDocumentFragment());
+    }
+
+    createTextNode(data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createTextNode' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createTextNode' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createTextNode(...args));
+    }
+
+    createCDATASection(data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createCDATASection' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createCDATASection' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createCDATASection(...args));
+    }
+
+    createComment(data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createComment' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createComment' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createComment(...args));
+    }
+
+    createProcessingInstruction(target, data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'createProcessingInstruction' on 'Document': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createProcessingInstruction' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createProcessingInstruction' on 'Document': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createProcessingInstruction(...args));
+    }
+
+    importNode(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'importNode' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'importNode' on 'Document': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'importNode' on 'Document': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].importNode(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    adoptNode(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'adoptNode' on 'Document': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'adoptNode' on 'Document': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].adoptNode(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    createAttribute(localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createAttribute' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createAttribute' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createAttribute(...args));
+    }
+
+    createAttributeNS(namespace, qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'createAttributeNS' on 'Document': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'createAttributeNS' on 'Document': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createAttributeNS' on 'Document': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createAttributeNS(...args));
+    }
+
+    createEvent(interface_) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createEvent' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createEvent' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createEvent(...args));
+    }
+
+    createRange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createRange());
+    }
+
+    createNodeIterator(root) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createNodeIterator' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'createNodeIterator' on 'Document': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned long"](curArg, {
+            context: "Failed to execute 'createNodeIterator' on 'Document': parameter 2"
+          });
+        } else {
+          curArg = 0xffffffff;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createNodeIterator(...args));
+    }
+
+    createTreeWalker(root) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'createTreeWalker' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'createTreeWalker' on 'Document': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned long"](curArg, {
+            context: "Failed to execute 'createTreeWalker' on 'Document': parameter 2"
+          });
+        } else {
+          curArg = 0xffffffff;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].createTreeWalker(...args));
+    }
+
+    getElementsByName(elementName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByName' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByName' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByName(...args));
+    }
+
+    open() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'open' on 'Document': parameter 1" });
+        } else {
+          curArg = "text/html";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'open' on 'Document': parameter 2" });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].open(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    close() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].close();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    write() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'write' on 'Document': parameter " + (i + 1)
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].write(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    writeln() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'writeln' on 'Document': parameter " + (i + 1)
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].writeln(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    hasFocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].hasFocus();
+    }
+
+    clear() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].clear();
+    }
+
+    captureEvents() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].captureEvents();
+    }
+
+    releaseEvents() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].releaseEvents();
+    }
+
+    getSelection() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].getSelection());
+    }
+
+    getElementById(elementId) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementById' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementById' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementById(...args));
+    }
+
+    prepend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'prepend' on 'Document': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].prepend(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    append() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'append' on 'Document': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].append(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    querySelector(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'querySelector' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'querySelector' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].querySelector(...args));
+    }
+
+    querySelectorAll(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'querySelectorAll' on 'Document': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'querySelectorAll' on 'Document': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].querySelectorAll(...args));
+    }
+
+    get implementation() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "implementation", () => {
+        return utils.tryWrapperForImpl(this[impl]["implementation"]);
+      });
+    }
+
+    get URL() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["URL"];
+    }
+
+    get documentURI() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["documentURI"];
+    }
+
+    get compatMode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["compatMode"];
+    }
+
+    get characterSet() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["characterSet"];
+    }
+
+    get charset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["charset"];
+    }
+
+    get inputEncoding() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["inputEncoding"];
+    }
+
+    get contentType() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["contentType"];
+    }
+
+    get doctype() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["doctype"]);
+    }
+
+    get documentElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["documentElement"]);
+    }
+
+    get referrer() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["referrer"];
+    }
+
+    get cookie() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["cookie"];
+    }
+
+    set cookie(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'cookie' property on 'Document': The provided value"
+      });
+
+      this[impl]["cookie"] = V;
+    }
+
+    get lastModified() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["lastModified"];
+    }
+
+    get readyState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["readyState"]);
+    }
+
+    get title() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["title"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set title(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'title' property on 'Document': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["title"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get dir() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["dir"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set dir(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'dir' property on 'Document': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["dir"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get body() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl]["body"]);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set body(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = convertHTMLElement(V, { context: "Failed to set the 'body' property on 'Document': The provided value" });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["body"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get head() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["head"]);
+    }
+
+    get images() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "images", () => {
+        return utils.tryWrapperForImpl(this[impl]["images"]);
+      });
+    }
+
+    get embeds() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "embeds", () => {
+        return utils.tryWrapperForImpl(this[impl]["embeds"]);
+      });
+    }
+
+    get plugins() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "plugins", () => {
+        return utils.tryWrapperForImpl(this[impl]["plugins"]);
+      });
+    }
+
+    get links() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "links", () => {
+        return utils.tryWrapperForImpl(this[impl]["links"]);
+      });
+    }
+
+    get forms() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "forms", () => {
+        return utils.tryWrapperForImpl(this[impl]["forms"]);
+      });
+    }
+
+    get scripts() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "scripts", () => {
+        return utils.tryWrapperForImpl(this[impl]["scripts"]);
+      });
+    }
+
+    get currentScript() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["currentScript"]);
+    }
+
+    get defaultView() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["defaultView"]);
+    }
+
+    get onreadystatechange() {
+      return utils.tryWrapperForImpl(this[impl]["onreadystatechange"]);
+    }
+
+    set onreadystatechange(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onreadystatechange"] = V;
+    }
+
+    get anchors() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "anchors", () => {
+        return utils.tryWrapperForImpl(this[impl]["anchors"]);
+      });
+    }
+
+    get applets() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "applets", () => {
+        return utils.tryWrapperForImpl(this[impl]["applets"]);
+      });
+    }
+
+    get styleSheets() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "styleSheets", () => {
+        return utils.tryWrapperForImpl(this[impl]["styleSheets"]);
+      });
+    }
+
+    get hidden() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["hidden"];
+    }
+
+    get visibilityState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["visibilityState"]);
+    }
+
+    get onvisibilitychange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onvisibilitychange"]);
+    }
+
+    set onvisibilitychange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onvisibilitychange"] = V;
+    }
+
+    get onabort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onabort"]);
+    }
+
+    set onabort(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onabort"] = V;
+    }
+
+    get onauxclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onauxclick"]);
+    }
+
+    set onauxclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onauxclick"] = V;
+    }
+
+    get onblur() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onblur"]);
+    }
+
+    set onblur(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onblur"] = V;
+    }
+
+    get oncancel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncancel"]);
+    }
+
+    set oncancel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncancel"] = V;
+    }
+
+    get oncanplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncanplay"]);
+    }
+
+    set oncanplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncanplay"] = V;
+    }
+
+    get oncanplaythrough() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncanplaythrough"]);
+    }
+
+    set oncanplaythrough(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncanplaythrough"] = V;
+    }
+
+    get onchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onchange"]);
+    }
+
+    set onchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onchange"] = V;
+    }
+
+    get onclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclick"]);
+    }
+
+    set onclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclick"] = V;
+    }
+
+    get onclose() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclose"]);
+    }
+
+    set onclose(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclose"] = V;
+    }
+
+    get oncontextmenu() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncontextmenu"]);
+    }
+
+    set oncontextmenu(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncontextmenu"] = V;
+    }
+
+    get oncuechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncuechange"]);
+    }
+
+    set oncuechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncuechange"] = V;
+    }
+
+    get ondblclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondblclick"]);
+    }
+
+    set ondblclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondblclick"] = V;
+    }
+
+    get ondrag() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondrag"]);
+    }
+
+    set ondrag(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondrag"] = V;
+    }
+
+    get ondragend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragend"]);
+    }
+
+    set ondragend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragend"] = V;
+    }
+
+    get ondragenter() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragenter"]);
+    }
+
+    set ondragenter(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragenter"] = V;
+    }
+
+    get ondragexit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragexit"]);
+    }
+
+    set ondragexit(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragexit"] = V;
+    }
+
+    get ondragleave() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragleave"]);
+    }
+
+    set ondragleave(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragleave"] = V;
+    }
+
+    get ondragover() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragover"]);
+    }
+
+    set ondragover(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragover"] = V;
+    }
+
+    get ondragstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragstart"]);
+    }
+
+    set ondragstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragstart"] = V;
+    }
+
+    get ondrop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondrop"]);
+    }
+
+    set ondrop(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondrop"] = V;
+    }
+
+    get ondurationchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondurationchange"]);
+    }
+
+    set ondurationchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondurationchange"] = V;
+    }
+
+    get onemptied() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onemptied"]);
+    }
+
+    set onemptied(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onemptied"] = V;
+    }
+
+    get onended() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onended"]);
+    }
+
+    set onended(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onended"] = V;
+    }
+
+    get onerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onerror"]);
+    }
+
+    set onerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onerror"] = V;
+    }
+
+    get onfocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onfocus"]);
+    }
+
+    set onfocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onfocus"] = V;
+    }
+
+    get oninput() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oninput"]);
+    }
+
+    set oninput(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oninput"] = V;
+    }
+
+    get oninvalid() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oninvalid"]);
+    }
+
+    set oninvalid(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oninvalid"] = V;
+    }
+
+    get onkeydown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeydown"]);
+    }
+
+    set onkeydown(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeydown"] = V;
+    }
+
+    get onkeypress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeypress"]);
+    }
+
+    set onkeypress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeypress"] = V;
+    }
+
+    get onkeyup() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeyup"]);
+    }
+
+    set onkeyup(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeyup"] = V;
+    }
+
+    get onload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onload"]);
+    }
+
+    set onload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onload"] = V;
+    }
+
+    get onloadeddata() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadeddata"]);
+    }
+
+    set onloadeddata(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadeddata"] = V;
+    }
+
+    get onloadedmetadata() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadedmetadata"]);
+    }
+
+    set onloadedmetadata(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadedmetadata"] = V;
+    }
+
+    get onloadend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadend"]);
+    }
+
+    set onloadend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadend"] = V;
+    }
+
+    get onloadstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadstart"]);
+    }
+
+    set onloadstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadstart"] = V;
+    }
+
+    get onmousedown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmousedown"]);
+    }
+
+    set onmousedown(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmousedown"] = V;
+    }
+
+    get onmouseenter() {
+      return utils.tryWrapperForImpl(this[impl]["onmouseenter"]);
+    }
+
+    set onmouseenter(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseenter"] = V;
+    }
+
+    get onmouseleave() {
+      return utils.tryWrapperForImpl(this[impl]["onmouseleave"]);
+    }
+
+    set onmouseleave(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseleave"] = V;
+    }
+
+    get onmousemove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmousemove"]);
+    }
+
+    set onmousemove(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmousemove"] = V;
+    }
+
+    get onmouseout() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseout"]);
+    }
+
+    set onmouseout(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseout"] = V;
+    }
+
+    get onmouseover() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseover"]);
+    }
+
+    set onmouseover(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseover"] = V;
+    }
+
+    get onmouseup() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseup"]);
+    }
+
+    set onmouseup(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseup"] = V;
+    }
+
+    get onwheel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onwheel"]);
+    }
+
+    set onwheel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onwheel"] = V;
+    }
+
+    get onpause() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpause"]);
+    }
+
+    set onpause(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpause"] = V;
+    }
+
+    get onplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onplay"]);
+    }
+
+    set onplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onplay"] = V;
+    }
+
+    get onplaying() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onplaying"]);
+    }
+
+    set onplaying(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onplaying"] = V;
+    }
+
+    get onprogress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onprogress"]);
+    }
+
+    set onprogress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onprogress"] = V;
+    }
+
+    get onratechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onratechange"]);
+    }
+
+    set onratechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onratechange"] = V;
+    }
+
+    get onreset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onreset"]);
+    }
+
+    set onreset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onreset"] = V;
+    }
+
+    get onresize() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onresize"]);
+    }
+
+    set onresize(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onresize"] = V;
+    }
+
+    get onscroll() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onscroll"]);
+    }
+
+    set onscroll(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onscroll"] = V;
+    }
+
+    get onsecuritypolicyviolation() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsecuritypolicyviolation"]);
+    }
+
+    set onsecuritypolicyviolation(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsecuritypolicyviolation"] = V;
+    }
+
+    get onseeked() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onseeked"]);
+    }
+
+    set onseeked(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onseeked"] = V;
+    }
+
+    get onseeking() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onseeking"]);
+    }
+
+    set onseeking(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onseeking"] = V;
+    }
+
+    get onselect() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onselect"]);
+    }
+
+    set onselect(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onselect"] = V;
+    }
+
+    get onstalled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onstalled"]);
+    }
+
+    set onstalled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onstalled"] = V;
+    }
+
+    get onsubmit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsubmit"]);
+    }
+
+    set onsubmit(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsubmit"] = V;
+    }
+
+    get onsuspend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsuspend"]);
+    }
+
+    set onsuspend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsuspend"] = V;
+    }
+
+    get ontimeupdate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontimeupdate"]);
+    }
+
+    set ontimeupdate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontimeupdate"] = V;
+    }
+
+    get ontoggle() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontoggle"]);
+    }
+
+    set ontoggle(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontoggle"] = V;
+    }
+
+    get onvolumechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onvolumechange"]);
+    }
+
+    set onvolumechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onvolumechange"] = V;
+    }
+
+    get onwaiting() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onwaiting"]);
+    }
+
+    set onwaiting(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onwaiting"] = V;
+    }
+
+    get activeElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["activeElement"]);
+    }
+
+    get children() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "children", () => {
+        return utils.tryWrapperForImpl(this[impl]["children"]);
+      });
+    }
+
+    get firstElementChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["firstElementChild"]);
+    }
+
+    get lastElementChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["lastElementChild"]);
+    }
+
+    get childElementCount() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["childElementCount"];
+    }
+  }
+  Object.defineProperties(Document.prototype, {
+    getElementsByTagName: { enumerable: true },
+    getElementsByTagNameNS: { enumerable: true },
+    getElementsByClassName: { enumerable: true },
+    createElement: { enumerable: true },
+    createElementNS: { enumerable: true },
+    createDocumentFragment: { enumerable: true },
+    createTextNode: { enumerable: true },
+    createCDATASection: { enumerable: true },
+    createComment: { enumerable: true },
+    createProcessingInstruction: { enumerable: true },
+    importNode: { enumerable: true },
+    adoptNode: { enumerable: true },
+    createAttribute: { enumerable: true },
+    createAttributeNS: { enumerable: true },
+    createEvent: { enumerable: true },
+    createRange: { enumerable: true },
+    createNodeIterator: { enumerable: true },
+    createTreeWalker: { enumerable: true },
+    getElementsByName: { enumerable: true },
+    open: { enumerable: true },
+    close: { enumerable: true },
+    write: { enumerable: true },
+    writeln: { enumerable: true },
+    hasFocus: { enumerable: true },
+    clear: { enumerable: true },
+    captureEvents: { enumerable: true },
+    releaseEvents: { enumerable: true },
+    getSelection: { enumerable: true },
+    getElementById: { enumerable: true },
+    prepend: { enumerable: true },
+    append: { enumerable: true },
+    querySelector: { enumerable: true },
+    querySelectorAll: { enumerable: true },
+    implementation: { enumerable: true },
+    URL: { enumerable: true },
+    documentURI: { enumerable: true },
+    compatMode: { enumerable: true },
+    characterSet: { enumerable: true },
+    charset: { enumerable: true },
+    inputEncoding: { enumerable: true },
+    contentType: { enumerable: true },
+    doctype: { enumerable: true },
+    documentElement: { enumerable: true },
+    referrer: { enumerable: true },
+    cookie: { enumerable: true },
+    lastModified: { enumerable: true },
+    readyState: { enumerable: true },
+    title: { enumerable: true },
+    dir: { enumerable: true },
+    body: { enumerable: true },
+    head: { enumerable: true },
+    images: { enumerable: true },
+    embeds: { enumerable: true },
+    plugins: { enumerable: true },
+    links: { enumerable: true },
+    forms: { enumerable: true },
+    scripts: { enumerable: true },
+    currentScript: { enumerable: true },
+    defaultView: { enumerable: true },
+    onreadystatechange: { enumerable: true },
+    anchors: { enumerable: true },
+    applets: { enumerable: true },
+    styleSheets: { enumerable: true },
+    hidden: { enumerable: true },
+    visibilityState: { enumerable: true },
+    onvisibilitychange: { enumerable: true },
+    onabort: { enumerable: true },
+    onauxclick: { enumerable: true },
+    onblur: { enumerable: true },
+    oncancel: { enumerable: true },
+    oncanplay: { enumerable: true },
+    oncanplaythrough: { enumerable: true },
+    onchange: { enumerable: true },
+    onclick: { enumerable: true },
+    onclose: { enumerable: true },
+    oncontextmenu: { enumerable: true },
+    oncuechange: { enumerable: true },
+    ondblclick: { enumerable: true },
+    ondrag: { enumerable: true },
+    ondragend: { enumerable: true },
+    ondragenter: { enumerable: true },
+    ondragexit: { enumerable: true },
+    ondragleave: { enumerable: true },
+    ondragover: { enumerable: true },
+    ondragstart: { enumerable: true },
+    ondrop: { enumerable: true },
+    ondurationchange: { enumerable: true },
+    onemptied: { enumerable: true },
+    onended: { enumerable: true },
+    onerror: { enumerable: true },
+    onfocus: { enumerable: true },
+    oninput: { enumerable: true },
+    oninvalid: { enumerable: true },
+    onkeydown: { enumerable: true },
+    onkeypress: { enumerable: true },
+    onkeyup: { enumerable: true },
+    onload: { enumerable: true },
+    onloadeddata: { enumerable: true },
+    onloadedmetadata: { enumerable: true },
+    onloadend: { enumerable: true },
+    onloadstart: { enumerable: true },
+    onmousedown: { enumerable: true },
+    onmouseenter: { enumerable: true },
+    onmouseleave: { enumerable: true },
+    onmousemove: { enumerable: true },
+    onmouseout: { enumerable: true },
+    onmouseover: { enumerable: true },
+    onmouseup: { enumerable: true },
+    onwheel: { enumerable: true },
+    onpause: { enumerable: true },
+    onplay: { enumerable: true },
+    onplaying: { enumerable: true },
+    onprogress: { enumerable: true },
+    onratechange: { enumerable: true },
+    onreset: { enumerable: true },
+    onresize: { enumerable: true },
+    onscroll: { enumerable: true },
+    onsecuritypolicyviolation: { enumerable: true },
+    onseeked: { enumerable: true },
+    onseeking: { enumerable: true },
+    onselect: { enumerable: true },
+    onstalled: { enumerable: true },
+    onsubmit: { enumerable: true },
+    onsuspend: { enumerable: true },
+    ontimeupdate: { enumerable: true },
+    ontoggle: { enumerable: true },
+    onvolumechange: { enumerable: true },
+    onwaiting: { enumerable: true },
+    activeElement: { enumerable: true },
+    children: { enumerable: true },
+    firstElementChild: { enumerable: true },
+    lastElementChild: { enumerable: true },
+    childElementCount: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Document", configurable: true },
+    [Symbol.unscopables]: { value: { prepend: true, append: true, __proto__: null }, configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Document;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Document
+  });
+};
+
+const Impl = require("../nodes/Document-impl.js");
diff --git a/lib/jsdom/living/generated/DocumentFragment.js b/lib/jsdom/living/generated/DocumentFragment.js
new file mode 100644
index 0000000..ac42532
--- /dev/null
+++ b/lib/jsdom/living/generated/DocumentFragment.js
@@ -0,0 +1,278 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isNode = require("./Node.js").is;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Node = require("./Node.js");
+
+const interfaceName = "DocumentFragment";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'DocumentFragment'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["DocumentFragment"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor DocumentFragment is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Node._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Node === undefined) {
+    throw new Error("Internal error: attempting to evaluate DocumentFragment before Node");
+  }
+  class DocumentFragment extends globalObject.Node {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    getElementById(elementId) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementById' on 'DocumentFragment': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementById' on 'DocumentFragment': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementById(...args));
+    }
+
+    prepend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'prepend' on 'DocumentFragment': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].prepend(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    append() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'append' on 'DocumentFragment': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].append(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    querySelector(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'querySelector' on 'DocumentFragment': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'querySelector' on 'DocumentFragment': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].querySelector(...args));
+    }
+
+    querySelectorAll(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'querySelectorAll' on 'DocumentFragment': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'querySelectorAll' on 'DocumentFragment': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].querySelectorAll(...args));
+    }
+
+    get children() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "children", () => {
+        return utils.tryWrapperForImpl(this[impl]["children"]);
+      });
+    }
+
+    get firstElementChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["firstElementChild"]);
+    }
+
+    get lastElementChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["lastElementChild"]);
+    }
+
+    get childElementCount() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["childElementCount"];
+    }
+  }
+  Object.defineProperties(DocumentFragment.prototype, {
+    getElementById: { enumerable: true },
+    prepend: { enumerable: true },
+    append: { enumerable: true },
+    querySelector: { enumerable: true },
+    querySelectorAll: { enumerable: true },
+    children: { enumerable: true },
+    firstElementChild: { enumerable: true },
+    lastElementChild: { enumerable: true },
+    childElementCount: { enumerable: true },
+    [Symbol.toStringTag]: { value: "DocumentFragment", configurable: true },
+    [Symbol.unscopables]: { value: { prepend: true, append: true, __proto__: null }, configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = DocumentFragment;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DocumentFragment
+  });
+};
+
+const Impl = require("../nodes/DocumentFragment-impl.js");
diff --git a/lib/jsdom/living/generated/DocumentReadyState.js b/lib/jsdom/living/generated/DocumentReadyState.js
new file mode 100644
index 0000000..13daec2
--- /dev/null
+++ b/lib/jsdom/living/generated/DocumentReadyState.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["loading", "interactive", "complete"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for DocumentReadyState`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/DocumentType.js b/lib/jsdom/living/generated/DocumentType.js
new file mode 100644
index 0000000..41bb8aa
--- /dev/null
+++ b/lib/jsdom/living/generated/DocumentType.js
@@ -0,0 +1,237 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isNode = require("./Node.js").is;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Node = require("./Node.js");
+
+const interfaceName = "DocumentType";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'DocumentType'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["DocumentType"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor DocumentType is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Node._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Node === undefined) {
+    throw new Error("Internal error: attempting to evaluate DocumentType before Node");
+  }
+  class DocumentType extends globalObject.Node {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    before() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'before' on 'DocumentType': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].before(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    after() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'after' on 'DocumentType': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].after(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    replaceWith() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'replaceWith' on 'DocumentType': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].replaceWith(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    remove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].remove();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["name"];
+    }
+
+    get publicId() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["publicId"];
+    }
+
+    get systemId() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["systemId"];
+    }
+  }
+  Object.defineProperties(DocumentType.prototype, {
+    before: { enumerable: true },
+    after: { enumerable: true },
+    replaceWith: { enumerable: true },
+    remove: { enumerable: true },
+    name: { enumerable: true },
+    publicId: { enumerable: true },
+    systemId: { enumerable: true },
+    [Symbol.toStringTag]: { value: "DocumentType", configurable: true },
+    [Symbol.unscopables]: {
+      value: { before: true, after: true, replaceWith: true, remove: true, __proto__: null },
+      configurable: true
+    }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = DocumentType;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DocumentType
+  });
+};
+
+const Impl = require("../nodes/DocumentType-impl.js");
diff --git a/lib/jsdom/living/generated/Element.js b/lib/jsdom/living/generated/Element.js
new file mode 100644
index 0000000..3244bb7
--- /dev/null
+++ b/lib/jsdom/living/generated/Element.js
@@ -0,0 +1,1471 @@
+"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 convertAttr = require("./Attr.js").convert;
+const convertShadowRootInit = require("./ShadowRootInit.js").convert;
+const isNode = require("./Node.js").is;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Node = require("./Node.js");
+
+const interfaceName = "Element";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Element'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Element"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Element is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Node._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Node === undefined) {
+    throw new Error("Internal error: attempting to evaluate Element before Node");
+  }
+  class Element extends globalObject.Node {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    hasAttributes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].hasAttributes();
+    }
+
+    getAttributeNames() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].getAttributeNames());
+    }
+
+    getAttribute(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getAttribute' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getAttribute' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].getAttribute(...args);
+    }
+
+    getAttributeNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'getAttributeNS' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'getAttributeNS' on 'Element': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getAttributeNS' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].getAttributeNS(...args);
+    }
+
+    setAttribute(qualifiedName, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'setAttribute' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setAttribute' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setAttribute' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].setAttribute(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    setAttributeNS(namespace, qualifiedName, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 3) {
+        throw new TypeError(
+          "Failed to execute 'setAttributeNS' on 'Element': 3 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'setAttributeNS' on 'Element': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setAttributeNS' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setAttributeNS' on 'Element': parameter 3"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].setAttributeNS(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    removeAttribute(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'removeAttribute' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'removeAttribute' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].removeAttribute(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    removeAttributeNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'removeAttributeNS' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'removeAttributeNS' on 'Element': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'removeAttributeNS' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].removeAttributeNS(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    toggleAttribute(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'toggleAttribute' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'toggleAttribute' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'toggleAttribute' on 'Element': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].toggleAttribute(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    hasAttribute(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'hasAttribute' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'hasAttribute' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].hasAttribute(...args);
+    }
+
+    hasAttributeNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'hasAttributeNS' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'hasAttributeNS' on 'Element': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'hasAttributeNS' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].hasAttributeNS(...args);
+    }
+
+    getAttributeNode(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getAttributeNode' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getAttributeNode' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getAttributeNode(...args));
+    }
+
+    getAttributeNodeNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'getAttributeNodeNS' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'getAttributeNodeNS' on 'Element': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getAttributeNodeNS' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getAttributeNodeNS(...args));
+    }
+
+    setAttributeNode(attr) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setAttributeNode' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAttr(curArg, { context: "Failed to execute 'setAttributeNode' on 'Element': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].setAttributeNode(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    setAttributeNodeNS(attr) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setAttributeNodeNS' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAttr(curArg, { context: "Failed to execute 'setAttributeNodeNS' on 'Element': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].setAttributeNodeNS(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    removeAttributeNode(attr) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'removeAttributeNode' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAttr(curArg, { context: "Failed to execute 'removeAttributeNode' on 'Element': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].removeAttributeNode(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    attachShadow(init) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'attachShadow' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertShadowRootInit(curArg, {
+          context: "Failed to execute 'attachShadow' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].attachShadow(...args));
+    }
+
+    closest(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'closest' on 'Element': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'closest' on 'Element': parameter 1" });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].closest(...args));
+    }
+
+    matches(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'matches' on 'Element': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'matches' on 'Element': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].matches(...args);
+    }
+
+    webkitMatchesSelector(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'webkitMatchesSelector' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'webkitMatchesSelector' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].webkitMatchesSelector(...args);
+    }
+
+    getElementsByTagName(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByTagName' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByTagName' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByTagName(...args));
+    }
+
+    getElementsByTagNameNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByTagNameNS' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'getElementsByTagNameNS' on 'Element': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByTagNameNS' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByTagNameNS(...args));
+    }
+
+    getElementsByClassName(classNames) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getElementsByClassName' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementsByClassName' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementsByClassName(...args));
+    }
+
+    insertAdjacentElement(where, element) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'insertAdjacentElement' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertAdjacentElement' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = module.exports.convert(curArg, {
+          context: "Failed to execute 'insertAdjacentElement' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].insertAdjacentElement(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    insertAdjacentText(where, data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'insertAdjacentText' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertAdjacentText' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertAdjacentText' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].insertAdjacentText(...args);
+    }
+
+    insertAdjacentHTML(position, text) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'insertAdjacentHTML' on 'Element': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertAdjacentHTML' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertAdjacentHTML' on 'Element': parameter 2"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].insertAdjacentHTML(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    getClientRects() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].getClientRects());
+    }
+
+    getBoundingClientRect() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].getBoundingClientRect());
+    }
+
+    before() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'before' on 'Element': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].before(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    after() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'after' on 'Element': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].after(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    replaceWith() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'replaceWith' on 'Element': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].replaceWith(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    remove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].remove();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    prepend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'prepend' on 'Element': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].prepend(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    append() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      for (let i = 0; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        if (isNode(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'append' on 'Element': parameter " + (i + 1)
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].append(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    querySelector(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'querySelector' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'querySelector' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].querySelector(...args));
+    }
+
+    querySelectorAll(selectors) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'querySelectorAll' on 'Element': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'querySelectorAll' on 'Element': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].querySelectorAll(...args));
+    }
+
+    get namespaceURI() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["namespaceURI"];
+    }
+
+    get prefix() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["prefix"];
+    }
+
+    get localName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["localName"];
+    }
+
+    get tagName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["tagName"];
+    }
+
+    get id() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "id");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set id(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, { context: "Failed to set the 'id' property on 'Element': The provided value" });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "id", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get className() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "class");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set className(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'className' property on 'Element': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "class", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get classList() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "classList", () => {
+        return utils.tryWrapperForImpl(this[impl]["classList"]);
+      });
+    }
+
+    set classList(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.classList.value = V;
+    }
+
+    get slot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "slot");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set slot(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'slot' property on 'Element': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "slot", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get attributes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "attributes", () => {
+        return utils.tryWrapperForImpl(this[impl]["attributes"]);
+      });
+    }
+
+    get shadowRoot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["shadowRoot"]);
+    }
+
+    get innerHTML() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["innerHTML"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set innerHTML(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'innerHTML' property on 'Element': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["innerHTML"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get outerHTML() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["outerHTML"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set outerHTML(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'outerHTML' property on 'Element': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["outerHTML"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get scrollTop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["scrollTop"];
+    }
+
+    set scrollTop(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unrestricted double"](V, {
+        context: "Failed to set the 'scrollTop' property on 'Element': The provided value"
+      });
+
+      this[impl]["scrollTop"] = V;
+    }
+
+    get scrollLeft() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["scrollLeft"];
+    }
+
+    set scrollLeft(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unrestricted double"](V, {
+        context: "Failed to set the 'scrollLeft' property on 'Element': The provided value"
+      });
+
+      this[impl]["scrollLeft"] = V;
+    }
+
+    get scrollWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["scrollWidth"];
+    }
+
+    get scrollHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["scrollHeight"];
+    }
+
+    get clientTop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["clientTop"];
+    }
+
+    get clientLeft() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["clientLeft"];
+    }
+
+    get clientWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["clientWidth"];
+    }
+
+    get clientHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["clientHeight"];
+    }
+
+    get previousElementSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["previousElementSibling"]);
+    }
+
+    get nextElementSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["nextElementSibling"]);
+    }
+
+    get children() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "children", () => {
+        return utils.tryWrapperForImpl(this[impl]["children"]);
+      });
+    }
+
+    get firstElementChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["firstElementChild"]);
+    }
+
+    get lastElementChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["lastElementChild"]);
+    }
+
+    get childElementCount() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["childElementCount"];
+    }
+
+    get assignedSlot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["assignedSlot"]);
+    }
+  }
+  Object.defineProperties(Element.prototype, {
+    hasAttributes: { enumerable: true },
+    getAttributeNames: { enumerable: true },
+    getAttribute: { enumerable: true },
+    getAttributeNS: { enumerable: true },
+    setAttribute: { enumerable: true },
+    setAttributeNS: { enumerable: true },
+    removeAttribute: { enumerable: true },
+    removeAttributeNS: { enumerable: true },
+    toggleAttribute: { enumerable: true },
+    hasAttribute: { enumerable: true },
+    hasAttributeNS: { enumerable: true },
+    getAttributeNode: { enumerable: true },
+    getAttributeNodeNS: { enumerable: true },
+    setAttributeNode: { enumerable: true },
+    setAttributeNodeNS: { enumerable: true },
+    removeAttributeNode: { enumerable: true },
+    attachShadow: { enumerable: true },
+    closest: { enumerable: true },
+    matches: { enumerable: true },
+    webkitMatchesSelector: { enumerable: true },
+    getElementsByTagName: { enumerable: true },
+    getElementsByTagNameNS: { enumerable: true },
+    getElementsByClassName: { enumerable: true },
+    insertAdjacentElement: { enumerable: true },
+    insertAdjacentText: { enumerable: true },
+    insertAdjacentHTML: { enumerable: true },
+    getClientRects: { enumerable: true },
+    getBoundingClientRect: { enumerable: true },
+    before: { enumerable: true },
+    after: { enumerable: true },
+    replaceWith: { enumerable: true },
+    remove: { enumerable: true },
+    prepend: { enumerable: true },
+    append: { enumerable: true },
+    querySelector: { enumerable: true },
+    querySelectorAll: { enumerable: true },
+    namespaceURI: { enumerable: true },
+    prefix: { enumerable: true },
+    localName: { enumerable: true },
+    tagName: { enumerable: true },
+    id: { enumerable: true },
+    className: { enumerable: true },
+    classList: { enumerable: true },
+    slot: { enumerable: true },
+    attributes: { enumerable: true },
+    shadowRoot: { enumerable: true },
+    innerHTML: { enumerable: true },
+    outerHTML: { enumerable: true },
+    scrollTop: { enumerable: true },
+    scrollLeft: { enumerable: true },
+    scrollWidth: { enumerable: true },
+    scrollHeight: { enumerable: true },
+    clientTop: { enumerable: true },
+    clientLeft: { enumerable: true },
+    clientWidth: { enumerable: true },
+    clientHeight: { enumerable: true },
+    previousElementSibling: { enumerable: true },
+    nextElementSibling: { enumerable: true },
+    children: { enumerable: true },
+    firstElementChild: { enumerable: true },
+    lastElementChild: { enumerable: true },
+    childElementCount: { enumerable: true },
+    assignedSlot: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Element", configurable: true },
+    [Symbol.unscopables]: {
+      value: {
+        slot: true,
+        before: true,
+        after: true,
+        replaceWith: true,
+        remove: true,
+        prepend: true,
+        append: true,
+        __proto__: null
+      },
+      configurable: true
+    }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Element;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Element
+  });
+};
+
+const Impl = require("../nodes/Element-impl.js");
diff --git a/lib/jsdom/living/generated/ElementCreationOptions.js b/lib/jsdom/living/generated/ElementCreationOptions.js
new file mode 100644
index 0000000..b938f37
--- /dev/null
+++ b/lib/jsdom/living/generated/ElementCreationOptions.js
@@ -0,0 +1,26 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "is";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member is that" });
+
+      ret[key] = value;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/ElementDefinitionOptions.js b/lib/jsdom/living/generated/ElementDefinitionOptions.js
new file mode 100644
index 0000000..6223a3a
--- /dev/null
+++ b/lib/jsdom/living/generated/ElementDefinitionOptions.js
@@ -0,0 +1,26 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "extends";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member extends that" });
+
+      ret[key] = value;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/EndingType.js b/lib/jsdom/living/generated/EndingType.js
new file mode 100644
index 0000000..503863a
--- /dev/null
+++ b/lib/jsdom/living/generated/EndingType.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["transparent", "native"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for EndingType`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/ErrorEvent.js b/lib/jsdom/living/generated/ErrorEvent.js
new file mode 100644
index 0000000..9d74608
--- /dev/null
+++ b/lib/jsdom/living/generated/ErrorEvent.js
@@ -0,0 +1,176 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertErrorEventInit = require("./ErrorEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "ErrorEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'ErrorEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["ErrorEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor ErrorEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate ErrorEvent before Event");
+  }
+  class ErrorEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'ErrorEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'ErrorEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertErrorEventInit(curArg, { context: "Failed to construct 'ErrorEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get message() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["message"];
+    }
+
+    get filename() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["filename"];
+    }
+
+    get lineno() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["lineno"];
+    }
+
+    get colno() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["colno"];
+    }
+
+    get error() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["error"];
+    }
+  }
+  Object.defineProperties(ErrorEvent.prototype, {
+    message: { enumerable: true },
+    filename: { enumerable: true },
+    lineno: { enumerable: true },
+    colno: { enumerable: true },
+    error: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ErrorEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = ErrorEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ErrorEvent
+  });
+};
+
+const Impl = require("../events/ErrorEvent-impl.js");
diff --git a/lib/jsdom/living/generated/ErrorEventInit.js b/lib/jsdom/living/generated/ErrorEventInit.js
new file mode 100644
index 0000000..848a682
--- /dev/null
+++ b/lib/jsdom/living/generated/ErrorEventInit.js
@@ -0,0 +1,80 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "colno";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member colno that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "error";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["any"](value, { context: context + " has member error that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "filename";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["USVString"](value, { context: context + " has member filename that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "lineno";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member lineno that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "message";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member message that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Event.js b/lib/jsdom/living/generated/Event.js
new file mode 100644
index 0000000..0e3d582
--- /dev/null
+++ b/lib/jsdom/living/generated/Event.js
@@ -0,0 +1,356 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertEventInit = require("./EventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Event";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Event'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Event"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Event is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Object.defineProperties(
+    obj,
+    Object.getOwnPropertyDescriptors({
+      get isTrusted() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["isTrusted"];
+      }
+    })
+  );
+
+  Object.defineProperties(obj, { isTrusted: { configurable: false } });
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'Event': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'Event': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertEventInit(curArg, { context: "Failed to construct 'Event': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    composedPath() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].composedPath());
+    }
+
+    stopPropagation() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].stopPropagation();
+    }
+
+    stopImmediatePropagation() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].stopImmediatePropagation();
+    }
+
+    preventDefault() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].preventDefault();
+    }
+
+    initEvent(type) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initEvent' on 'Event': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'initEvent' on 'Event': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, { context: "Failed to execute 'initEvent' on 'Event': parameter 2" });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, { context: "Failed to execute 'initEvent' on 'Event': parameter 3" });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return this[impl].initEvent(...args);
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["target"]);
+    }
+
+    get srcElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["srcElement"]);
+    }
+
+    get currentTarget() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["currentTarget"]);
+    }
+
+    get eventPhase() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["eventPhase"];
+    }
+
+    get cancelBubble() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["cancelBubble"];
+    }
+
+    set cancelBubble(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'cancelBubble' property on 'Event': The provided value"
+      });
+
+      this[impl]["cancelBubble"] = V;
+    }
+
+    get bubbles() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["bubbles"];
+    }
+
+    get cancelable() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["cancelable"];
+    }
+
+    get returnValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["returnValue"];
+    }
+
+    set returnValue(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'returnValue' property on 'Event': The provided value"
+      });
+
+      this[impl]["returnValue"] = V;
+    }
+
+    get defaultPrevented() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["defaultPrevented"];
+    }
+
+    get composed() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["composed"];
+    }
+
+    get timeStamp() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["timeStamp"];
+    }
+  }
+  Object.defineProperties(Event.prototype, {
+    composedPath: { enumerable: true },
+    stopPropagation: { enumerable: true },
+    stopImmediatePropagation: { enumerable: true },
+    preventDefault: { enumerable: true },
+    initEvent: { enumerable: true },
+    type: { enumerable: true },
+    target: { enumerable: true },
+    srcElement: { enumerable: true },
+    currentTarget: { enumerable: true },
+    eventPhase: { enumerable: true },
+    cancelBubble: { enumerable: true },
+    bubbles: { enumerable: true },
+    cancelable: { enumerable: true },
+    returnValue: { enumerable: true },
+    defaultPrevented: { enumerable: true },
+    composed: { enumerable: true },
+    timeStamp: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Event", configurable: true },
+    NONE: { value: 0, enumerable: true },
+    CAPTURING_PHASE: { value: 1, enumerable: true },
+    AT_TARGET: { value: 2, enumerable: true },
+    BUBBLING_PHASE: { value: 3, enumerable: true }
+  });
+  Object.defineProperties(Event, {
+    NONE: { value: 0, enumerable: true },
+    CAPTURING_PHASE: { value: 1, enumerable: true },
+    AT_TARGET: { value: 2, enumerable: true },
+    BUBBLING_PHASE: { value: 3, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Event;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Event
+  });
+};
+
+const Impl = require("../events/Event-impl.js");
diff --git a/lib/jsdom/living/generated/EventInit.js b/lib/jsdom/living/generated/EventInit.js
new file mode 100644
index 0000000..9dacecc
--- /dev/null
+++ b/lib/jsdom/living/generated/EventInit.js
@@ -0,0 +1,52 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "bubbles";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member bubbles that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "cancelable";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member cancelable that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "composed";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member composed that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/EventListenerOptions.js b/lib/jsdom/living/generated/EventListenerOptions.js
new file mode 100644
index 0000000..d8bc05d
--- /dev/null
+++ b/lib/jsdom/living/generated/EventListenerOptions.js
@@ -0,0 +1,28 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "capture";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member capture that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/EventModifierInit.js b/lib/jsdom/living/generated/EventModifierInit.js
new file mode 100644
index 0000000..f147038
--- /dev/null
+++ b/lib/jsdom/living/generated/EventModifierInit.js
@@ -0,0 +1,188 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const UIEventInit = require("./UIEventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  UIEventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "altKey";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member altKey that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "ctrlKey";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member ctrlKey that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "metaKey";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member metaKey that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierAltGraph";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierAltGraph that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierCapsLock";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierCapsLock that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierFn";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierFn that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierFnLock";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierFnLock that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierHyper";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierHyper that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierNumLock";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierNumLock that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierScrollLock";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierScrollLock that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierSuper";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierSuper that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierSymbol";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierSymbol that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "modifierSymbolLock";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member modifierSymbolLock that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "shiftKey";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member shiftKey that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/EventTarget.js b/lib/jsdom/living/generated/EventTarget.js
new file mode 100644
index 0000000..9529a8e
--- /dev/null
+++ b/lib/jsdom/living/generated/EventTarget.js
@@ -0,0 +1,245 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertAddEventListenerOptions = require("./AddEventListenerOptions.js").convert;
+const convertEventListenerOptions = require("./EventListenerOptions.js").convert;
+const convertEvent = require("./Event.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "EventTarget";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'EventTarget'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["EventTarget"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor EventTarget is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class EventTarget {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    addEventListener(type, callback) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'addEventListener' on 'EventTarget': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'addEventListener' on 'EventTarget': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = utils.tryImplForWrapper(curArg);
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = convertAddEventListenerOptions(curArg, {
+              context: "Failed to execute 'addEventListener' on 'EventTarget': parameter 3"
+            });
+          } else if (utils.isObject(curArg)) {
+            curArg = convertAddEventListenerOptions(curArg, {
+              context: "Failed to execute 'addEventListener' on 'EventTarget': parameter 3" + " dictionary"
+            });
+          } else if (typeof curArg === "boolean") {
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'addEventListener' on 'EventTarget': parameter 3"
+            });
+          } else {
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'addEventListener' on 'EventTarget': parameter 3"
+            });
+          }
+        }
+        args.push(curArg);
+      }
+      return this[impl].addEventListener(...args);
+    }
+
+    removeEventListener(type, callback) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'removeEventListener' on 'EventTarget': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'removeEventListener' on 'EventTarget': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = utils.tryImplForWrapper(curArg);
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = convertEventListenerOptions(curArg, {
+              context: "Failed to execute 'removeEventListener' on 'EventTarget': parameter 3"
+            });
+          } else if (utils.isObject(curArg)) {
+            curArg = convertEventListenerOptions(curArg, {
+              context: "Failed to execute 'removeEventListener' on 'EventTarget': parameter 3" + " dictionary"
+            });
+          } else if (typeof curArg === "boolean") {
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'removeEventListener' on 'EventTarget': parameter 3"
+            });
+          } else {
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'removeEventListener' on 'EventTarget': parameter 3"
+            });
+          }
+        }
+        args.push(curArg);
+      }
+      return this[impl].removeEventListener(...args);
+    }
+
+    dispatchEvent(event) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'dispatchEvent' on 'EventTarget': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertEvent(curArg, { context: "Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].dispatchEvent(...args);
+    }
+  }
+  Object.defineProperties(EventTarget.prototype, {
+    addEventListener: { enumerable: true },
+    removeEventListener: { enumerable: true },
+    dispatchEvent: { enumerable: true },
+    [Symbol.toStringTag]: { value: "EventTarget", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = EventTarget;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: EventTarget
+  });
+};
+
+const Impl = require("../events/EventTarget-impl.js");
diff --git a/lib/jsdom/living/generated/External.js b/lib/jsdom/living/generated/External.js
new file mode 100644
index 0000000..41e4149
--- /dev/null
+++ b/lib/jsdom/living/generated/External.js
@@ -0,0 +1,126 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "External";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'External'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["External"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor External is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class External {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    AddSearchProvider() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].AddSearchProvider();
+    }
+
+    IsSearchProviderInstalled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].IsSearchProviderInstalled();
+    }
+  }
+  Object.defineProperties(External.prototype, {
+    AddSearchProvider: { enumerable: true },
+    IsSearchProviderInstalled: { enumerable: true },
+    [Symbol.toStringTag]: { value: "External", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = External;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: External
+  });
+};
+
+const Impl = require("../window/External-impl.js");
diff --git a/lib/jsdom/living/generated/File.js b/lib/jsdom/living/generated/File.js
new file mode 100644
index 0000000..fa2d373
--- /dev/null
+++ b/lib/jsdom/living/generated/File.js
@@ -0,0 +1,173 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isBlob = require("./Blob.js").is;
+const convertFilePropertyBag = require("./FilePropertyBag.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Blob = require("./Blob.js");
+
+const interfaceName = "File";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'File'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["File"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor File is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Blob._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Blob === undefined) {
+    throw new Error("Internal error: attempting to evaluate File before Blob");
+  }
+  class File extends globalObject.Blob {
+    constructor(fileBits, fileName) {
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to construct 'File': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (!utils.isObject(curArg)) {
+          throw new TypeError("Failed to construct 'File': parameter 1" + " is not an iterable object.");
+        } else {
+          const V = [];
+          const tmp = curArg;
+          for (let nextItem of tmp) {
+            if (isBlob(nextItem)) {
+              nextItem = utils.implForWrapper(nextItem);
+            } else if (utils.isArrayBuffer(nextItem)) {
+            } else if (ArrayBuffer.isView(nextItem)) {
+            } else {
+              nextItem = conversions["USVString"](nextItem, {
+                context: "Failed to construct 'File': parameter 1" + "'s element"
+              });
+            }
+            V.push(nextItem);
+          }
+          curArg = V;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["USVString"](curArg, { context: "Failed to construct 'File': parameter 2" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = convertFilePropertyBag(curArg, { context: "Failed to construct 'File': parameter 3" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["name"];
+    }
+
+    get lastModified() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["lastModified"];
+    }
+  }
+  Object.defineProperties(File.prototype, {
+    name: { enumerable: true },
+    lastModified: { enumerable: true },
+    [Symbol.toStringTag]: { value: "File", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = File;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: File
+  });
+};
+
+const Impl = require("../file-api/File-impl.js");
diff --git a/lib/jsdom/living/generated/FileList.js b/lib/jsdom/living/generated/FileList.js
new file mode 100644
index 0000000..1e399e8
--- /dev/null
+++ b/lib/jsdom/living/generated/FileList.js
@@ -0,0 +1,300 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "FileList";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'FileList'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["FileList"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor FileList is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class FileList {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'FileList': 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 'FileList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+  }
+  Object.defineProperties(FileList.prototype, {
+    item: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "FileList", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = FileList;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: FileList
+  });
+};
+
+const proxyHandler = {
+  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[impl][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[impl].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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../file-api/FileList-impl.js");
diff --git a/lib/jsdom/living/generated/FilePropertyBag.js b/lib/jsdom/living/generated/FilePropertyBag.js
new file mode 100644
index 0000000..c359de2
--- /dev/null
+++ b/lib/jsdom/living/generated/FilePropertyBag.js
@@ -0,0 +1,30 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const BlobPropertyBag = require("./BlobPropertyBag.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  BlobPropertyBag.convertInherit(obj, ret, { context });
+
+  {
+    const key = "lastModified";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long long"](value, { context: context + " has member lastModified that" });
+
+      ret[key] = value;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/FileReader.js b/lib/jsdom/living/generated/FileReader.js
new file mode 100644
index 0000000..2135b73
--- /dev/null
+++ b/lib/jsdom/living/generated/FileReader.js
@@ -0,0 +1,372 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertBlob = require("./Blob.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "FileReader";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'FileReader'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["FileReader"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor FileReader is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  EventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.EventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate FileReader before EventTarget");
+  }
+  class FileReader extends globalObject.EventTarget {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    readAsArrayBuffer(blob) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'readAsArrayBuffer' on 'FileReader': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertBlob(curArg, { context: "Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].readAsArrayBuffer(...args);
+    }
+
+    readAsBinaryString(blob) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'readAsBinaryString' on 'FileReader': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertBlob(curArg, {
+          context: "Failed to execute 'readAsBinaryString' on 'FileReader': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].readAsBinaryString(...args);
+    }
+
+    readAsText(blob) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'readAsText' on 'FileReader': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertBlob(curArg, { context: "Failed to execute 'readAsText' on 'FileReader': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'readAsText' on 'FileReader': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].readAsText(...args);
+    }
+
+    readAsDataURL(blob) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'readAsDataURL' on 'FileReader': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertBlob(curArg, { context: "Failed to execute 'readAsDataURL' on 'FileReader': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].readAsDataURL(...args);
+    }
+
+    abort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].abort();
+    }
+
+    get readyState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["readyState"];
+    }
+
+    get result() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["result"]);
+    }
+
+    get error() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["error"]);
+    }
+
+    get onloadstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadstart"]);
+    }
+
+    set onloadstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadstart"] = V;
+    }
+
+    get onprogress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onprogress"]);
+    }
+
+    set onprogress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onprogress"] = V;
+    }
+
+    get onload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onload"]);
+    }
+
+    set onload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onload"] = V;
+    }
+
+    get onabort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onabort"]);
+    }
+
+    set onabort(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onabort"] = V;
+    }
+
+    get onerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onerror"]);
+    }
+
+    set onerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onerror"] = V;
+    }
+
+    get onloadend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadend"]);
+    }
+
+    set onloadend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadend"] = V;
+    }
+  }
+  Object.defineProperties(FileReader.prototype, {
+    readAsArrayBuffer: { enumerable: true },
+    readAsBinaryString: { enumerable: true },
+    readAsText: { enumerable: true },
+    readAsDataURL: { enumerable: true },
+    abort: { enumerable: true },
+    readyState: { enumerable: true },
+    result: { enumerable: true },
+    error: { enumerable: true },
+    onloadstart: { enumerable: true },
+    onprogress: { enumerable: true },
+    onload: { enumerable: true },
+    onabort: { enumerable: true },
+    onerror: { enumerable: true },
+    onloadend: { enumerable: true },
+    [Symbol.toStringTag]: { value: "FileReader", configurable: true },
+    EMPTY: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    DONE: { value: 2, enumerable: true }
+  });
+  Object.defineProperties(FileReader, {
+    EMPTY: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    DONE: { value: 2, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = FileReader;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: FileReader
+  });
+};
+
+const Impl = require("../file-api/FileReader-impl.js");
diff --git a/lib/jsdom/living/generated/FocusEvent.js b/lib/jsdom/living/generated/FocusEvent.js
new file mode 100644
index 0000000..977df5f
--- /dev/null
+++ b/lib/jsdom/living/generated/FocusEvent.js
@@ -0,0 +1,140 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertFocusEventInit = require("./FocusEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const UIEvent = require("./UIEvent.js");
+
+const interfaceName = "FocusEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'FocusEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["FocusEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor FocusEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  UIEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.UIEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate FocusEvent before UIEvent");
+  }
+  class FocusEvent extends globalObject.UIEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'FocusEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'FocusEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertFocusEventInit(curArg, { context: "Failed to construct 'FocusEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get relatedTarget() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["relatedTarget"]);
+    }
+  }
+  Object.defineProperties(FocusEvent.prototype, {
+    relatedTarget: { enumerable: true },
+    [Symbol.toStringTag]: { value: "FocusEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = FocusEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: FocusEvent
+  });
+};
+
+const Impl = require("../events/FocusEvent-impl.js");
diff --git a/lib/jsdom/living/generated/FocusEventInit.js b/lib/jsdom/living/generated/FocusEventInit.js
new file mode 100644
index 0000000..2ce4bc3
--- /dev/null
+++ b/lib/jsdom/living/generated/FocusEventInit.js
@@ -0,0 +1,36 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertEventTarget = require("./EventTarget.js").convert;
+const UIEventInit = require("./UIEventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  UIEventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "relatedTarget";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = convertEventTarget(value, { context: context + " has member relatedTarget that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/FormData.js b/lib/jsdom/living/generated/FormData.js
new file mode 100644
index 0000000..57db56f
--- /dev/null
+++ b/lib/jsdom/living/generated/FormData.js
@@ -0,0 +1,428 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertHTMLFormElement = require("./HTMLFormElement.js").convert;
+const isBlob = require("./Blob.js").is;
+const convertBlob = require("./Blob.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "FormData";
+
+const IteratorPrototype = Object.create(utils.IteratorPrototype, {
+  next: {
+    value: function next() {
+      const internal = this[utils.iterInternalSymbol];
+      const { target, kind, index } = internal;
+      const values = Array.from(target[impl]);
+      const len = values.length;
+      if (index >= len) {
+        return { value: undefined, done: true };
+      }
+
+      const pair = values[index];
+      internal.index = index + 1;
+      const [key, value] = pair.map(utils.tryWrapperForImpl);
+
+      let result;
+      switch (kind) {
+        case "key":
+          result = key;
+          break;
+        case "value":
+          result = value;
+          break;
+        case "key+value":
+          result = [key, value];
+          break;
+      }
+      return { value: result, done: false };
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  },
+  [Symbol.toStringTag]: {
+    value: "FormData Iterator",
+    configurable: true
+  }
+});
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'FormData'.`);
+};
+
+exports.createDefaultIterator = function createDefaultIterator(target, kind) {
+  const iterator = Object.create(IteratorPrototype);
+  Object.defineProperty(iterator, utils.iterInternalSymbol, {
+    value: { target, kind, index: 0 },
+    configurable: true
+  });
+  return iterator;
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["FormData"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor FormData is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class FormData {
+    constructor() {
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = convertHTMLFormElement(curArg, { context: "Failed to construct 'FormData': parameter 1" });
+        }
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    append(name, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'append' on 'FormData': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      switch (arguments.length) {
+        case 2:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'append' on 'FormData': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            if (isBlob(curArg)) {
+              {
+                let curArg = arguments[1];
+                curArg = convertBlob(curArg, { context: "Failed to execute 'append' on 'FormData': parameter 2" });
+                args.push(curArg);
+              }
+            } else {
+              {
+                let curArg = arguments[1];
+                curArg = conversions["USVString"](curArg, {
+                  context: "Failed to execute 'append' on 'FormData': parameter 2"
+                });
+                args.push(curArg);
+              }
+            }
+          }
+          break;
+        default:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'append' on 'FormData': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = convertBlob(curArg, { context: "Failed to execute 'append' on 'FormData': parameter 2" });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            if (curArg !== undefined) {
+              curArg = conversions["USVString"](curArg, {
+                context: "Failed to execute 'append' on 'FormData': parameter 3"
+              });
+            }
+            args.push(curArg);
+          }
+      }
+      return this[impl].append(...args);
+    }
+
+    delete(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'delete' on 'FormData': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["USVString"](curArg, { context: "Failed to execute 'delete' on 'FormData': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].delete(...args);
+    }
+
+    get(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'get' on 'FormData': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["USVString"](curArg, { context: "Failed to execute 'get' on 'FormData': parameter 1" });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].get(...args));
+    }
+
+    getAll(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getAll' on 'FormData': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["USVString"](curArg, { context: "Failed to execute 'getAll' on 'FormData': parameter 1" });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getAll(...args));
+    }
+
+    has(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'has' on 'FormData': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["USVString"](curArg, { context: "Failed to execute 'has' on 'FormData': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].has(...args);
+    }
+
+    set(name, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'set' on 'FormData': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      switch (arguments.length) {
+        case 2:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'set' on 'FormData': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            if (isBlob(curArg)) {
+              {
+                let curArg = arguments[1];
+                curArg = convertBlob(curArg, { context: "Failed to execute 'set' on 'FormData': parameter 2" });
+                args.push(curArg);
+              }
+            } else {
+              {
+                let curArg = arguments[1];
+                curArg = conversions["USVString"](curArg, {
+                  context: "Failed to execute 'set' on 'FormData': parameter 2"
+                });
+                args.push(curArg);
+              }
+            }
+          }
+          break;
+        default:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'set' on 'FormData': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = convertBlob(curArg, { context: "Failed to execute 'set' on 'FormData': parameter 2" });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            if (curArg !== undefined) {
+              curArg = conversions["USVString"](curArg, {
+                context: "Failed to execute 'set' on 'FormData': parameter 3"
+              });
+            }
+            args.push(curArg);
+          }
+      }
+      return this[impl].set(...args);
+    }
+
+    keys() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      return exports.createDefaultIterator(this, "key");
+    }
+
+    values() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      return exports.createDefaultIterator(this, "value");
+    }
+
+    entries() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      return exports.createDefaultIterator(this, "key+value");
+    }
+
+    forEach(callback) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      if (arguments.length < 1) {
+        throw new TypeError("Failed to execute 'forEach' on 'iterable': 1 argument required, " + "but only 0 present.");
+      }
+      if (typeof callback !== "function") {
+        throw new TypeError(
+          "Failed to execute 'forEach' on 'iterable': The callback provided " + "as parameter 1 is not a function."
+        );
+      }
+      const thisArg = arguments[1];
+      let pairs = Array.from(this[impl]);
+      let i = 0;
+      while (i < pairs.length) {
+        const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
+        callback.call(thisArg, value, key, this);
+        pairs = Array.from(this[impl]);
+        i++;
+      }
+    }
+  }
+  Object.defineProperties(FormData.prototype, {
+    append: { enumerable: true },
+    delete: { enumerable: true },
+    get: { enumerable: true },
+    getAll: { enumerable: true },
+    has: { enumerable: true },
+    set: { enumerable: true },
+    keys: { enumerable: true },
+    values: { enumerable: true },
+    entries: { enumerable: true },
+    forEach: { enumerable: true },
+    [Symbol.toStringTag]: { value: "FormData", configurable: true },
+    [Symbol.iterator]: { value: FormData.prototype.entries, configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = FormData;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: FormData
+  });
+};
+
+const Impl = require("../xhr/FormData-impl.js");
diff --git a/lib/jsdom/living/generated/GetRootNodeOptions.js b/lib/jsdom/living/generated/GetRootNodeOptions.js
new file mode 100644
index 0000000..4699472
--- /dev/null
+++ b/lib/jsdom/living/generated/GetRootNodeOptions.js
@@ -0,0 +1,28 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "composed";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member composed that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/HTMLAnchorElement.js b/lib/jsdom/living/generated/HTMLAnchorElement.js
new file mode 100644
index 0000000..8b2c1fa
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLAnchorElement.js
@@ -0,0 +1,820 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLAnchorElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLAnchorElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLAnchorElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLAnchorElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLAnchorElement before HTMLElement");
+  }
+  class HTMLAnchorElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "target");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set target(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'target' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "target", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get download() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "download");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set download(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'download' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "download", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rel");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rel' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rel", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get relList() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "relList", () => {
+        return utils.tryWrapperForImpl(this[impl]["relList"]);
+      });
+    }
+
+    set relList(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.relList.value = V;
+    }
+
+    get hreflang() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "hreflang");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hreflang(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'hreflang' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "hreflang", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get text() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["text"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set text(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'text' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["text"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get coords() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "coords");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set coords(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'coords' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "coords", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get charset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charset");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set charset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'charset' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charset", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rev() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rev");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rev(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rev' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rev", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get shape() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "shape");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set shape(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'shape' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "shape", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get href() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["href"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set href(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'href' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["href"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    toString() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["href"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get origin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["origin"];
+    }
+
+    get protocol() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["protocol"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set protocol(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'protocol' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["protocol"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get username() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["username"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set username(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'username' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["username"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get password() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["password"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set password(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'password' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["password"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get host() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["host"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set host(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'host' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["host"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hostname() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["hostname"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hostname(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'hostname' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["hostname"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get port() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["port"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set port(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'port' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["port"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get pathname() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["pathname"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set pathname(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'pathname' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["pathname"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get search() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["search"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set search(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'search' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["search"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hash() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["hash"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hash(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'hash' property on 'HTMLAnchorElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["hash"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLAnchorElement.prototype, {
+    target: { enumerable: true },
+    download: { enumerable: true },
+    rel: { enumerable: true },
+    relList: { enumerable: true },
+    hreflang: { enumerable: true },
+    type: { enumerable: true },
+    text: { enumerable: true },
+    coords: { enumerable: true },
+    charset: { enumerable: true },
+    name: { enumerable: true },
+    rev: { enumerable: true },
+    shape: { enumerable: true },
+    href: { enumerable: true },
+    toString: { enumerable: true },
+    origin: { enumerable: true },
+    protocol: { enumerable: true },
+    username: { enumerable: true },
+    password: { enumerable: true },
+    host: { enumerable: true },
+    hostname: { enumerable: true },
+    port: { enumerable: true },
+    pathname: { enumerable: true },
+    search: { enumerable: true },
+    hash: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLAnchorElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLAnchorElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLAnchorElement
+  });
+};
+
+const Impl = require("../nodes/HTMLAnchorElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLAreaElement.js b/lib/jsdom/living/generated/HTMLAreaElement.js
new file mode 100644
index 0000000..f690524
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLAreaElement.js
@@ -0,0 +1,664 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLAreaElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLAreaElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLAreaElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLAreaElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLAreaElement before HTMLElement");
+  }
+  class HTMLAreaElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get alt() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "alt");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set alt(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'alt' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "alt", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get coords() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "coords");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set coords(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'coords' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "coords", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get shape() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "shape");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set shape(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'shape' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "shape", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "target");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set target(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'target' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "target", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rel");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rel' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rel", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get relList() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "relList", () => {
+        return utils.tryWrapperForImpl(this[impl]["relList"]);
+      });
+    }
+
+    set relList(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.relList.value = V;
+    }
+
+    get noHref() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "nohref");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set noHref(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'noHref' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "nohref", "");
+        } else {
+          this[impl].removeAttributeNS(null, "nohref");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get href() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["href"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set href(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'href' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["href"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    toString() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["href"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get origin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["origin"];
+    }
+
+    get protocol() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["protocol"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set protocol(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'protocol' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["protocol"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get username() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["username"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set username(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'username' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["username"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get password() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["password"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set password(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'password' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["password"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get host() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["host"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set host(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'host' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["host"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hostname() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["hostname"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hostname(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'hostname' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["hostname"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get port() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["port"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set port(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'port' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["port"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get pathname() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["pathname"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set pathname(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'pathname' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["pathname"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get search() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["search"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set search(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'search' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["search"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hash() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["hash"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hash(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'hash' property on 'HTMLAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["hash"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLAreaElement.prototype, {
+    alt: { enumerable: true },
+    coords: { enumerable: true },
+    shape: { enumerable: true },
+    target: { enumerable: true },
+    rel: { enumerable: true },
+    relList: { enumerable: true },
+    noHref: { enumerable: true },
+    href: { enumerable: true },
+    toString: { enumerable: true },
+    origin: { enumerable: true },
+    protocol: { enumerable: true },
+    username: { enumerable: true },
+    password: { enumerable: true },
+    host: { enumerable: true },
+    hostname: { enumerable: true },
+    port: { enumerable: true },
+    pathname: { enumerable: true },
+    search: { enumerable: true },
+    hash: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLAreaElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLAreaElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLAreaElement
+  });
+};
+
+const Impl = require("../nodes/HTMLAreaElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLAudioElement.js b/lib/jsdom/living/generated/HTMLAudioElement.js
new file mode 100644
index 0000000..7687902
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLAudioElement.js
@@ -0,0 +1,115 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLMediaElement = require("./HTMLMediaElement.js");
+
+const interfaceName = "HTMLAudioElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLAudioElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLAudioElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLAudioElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLMediaElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLMediaElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLAudioElement before HTMLMediaElement");
+  }
+  class HTMLAudioElement extends globalObject.HTMLMediaElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+  }
+  Object.defineProperties(HTMLAudioElement.prototype, {
+    [Symbol.toStringTag]: { value: "HTMLAudioElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLAudioElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLAudioElement
+  });
+};
+
+const Impl = require("../nodes/HTMLAudioElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLBRElement.js b/lib/jsdom/living/generated/HTMLBRElement.js
new file mode 100644
index 0000000..9f6e090
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLBRElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLBRElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLBRElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLBRElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLBRElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLBRElement before HTMLElement");
+  }
+  class HTMLBRElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get clear() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "clear");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set clear(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'clear' property on 'HTMLBRElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "clear", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLBRElement.prototype, {
+    clear: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLBRElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLBRElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLBRElement
+  });
+};
+
+const Impl = require("../nodes/HTMLBRElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLBaseElement.js b/lib/jsdom/living/generated/HTMLBaseElement.js
new file mode 100644
index 0000000..e7bc828
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLBaseElement.js
@@ -0,0 +1,180 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLBaseElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLBaseElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLBaseElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLBaseElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLBaseElement before HTMLElement");
+  }
+  class HTMLBaseElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get href() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["href"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set href(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'href' property on 'HTMLBaseElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["href"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "target");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set target(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'target' property on 'HTMLBaseElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "target", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLBaseElement.prototype, {
+    href: { enumerable: true },
+    target: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLBaseElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLBaseElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLBaseElement
+  });
+};
+
+const Impl = require("../nodes/HTMLBaseElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLBodyElement.js b/lib/jsdom/living/generated/HTMLBodyElement.js
new file mode 100644
index 0000000..331273c
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLBodyElement.js
@@ -0,0 +1,618 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLBodyElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLBodyElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLBodyElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLBodyElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLBodyElement before HTMLElement");
+  }
+  class HTMLBodyElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get text() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "text");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set text(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'text' property on 'HTMLBodyElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "text", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get link() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "link");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set link(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'link' property on 'HTMLBodyElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "link", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vLink() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "vlink");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vLink(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'vLink' property on 'HTMLBodyElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "vlink", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get aLink() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "alink");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set aLink(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'aLink' property on 'HTMLBodyElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "alink", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get bgColor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "bgcolor");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set bgColor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'bgColor' property on 'HTMLBodyElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "bgcolor", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get background() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "background");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set background(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'background' property on 'HTMLBodyElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "background", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get onafterprint() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onafterprint"]);
+    }
+
+    set onafterprint(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onafterprint"] = V;
+    }
+
+    get onbeforeprint() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onbeforeprint"]);
+    }
+
+    set onbeforeprint(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onbeforeprint"] = V;
+    }
+
+    get onbeforeunload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onbeforeunload"]);
+    }
+
+    set onbeforeunload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onbeforeunload"] = V;
+    }
+
+    get onhashchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onhashchange"]);
+    }
+
+    set onhashchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onhashchange"] = V;
+    }
+
+    get onlanguagechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onlanguagechange"]);
+    }
+
+    set onlanguagechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onlanguagechange"] = V;
+    }
+
+    get onmessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessage"]);
+    }
+
+    set onmessage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessage"] = V;
+    }
+
+    get onmessageerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessageerror"]);
+    }
+
+    set onmessageerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessageerror"] = V;
+    }
+
+    get onoffline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onoffline"]);
+    }
+
+    set onoffline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onoffline"] = V;
+    }
+
+    get ononline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ononline"]);
+    }
+
+    set ononline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ononline"] = V;
+    }
+
+    get onpagehide() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpagehide"]);
+    }
+
+    set onpagehide(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpagehide"] = V;
+    }
+
+    get onpageshow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpageshow"]);
+    }
+
+    set onpageshow(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpageshow"] = V;
+    }
+
+    get onpopstate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpopstate"]);
+    }
+
+    set onpopstate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpopstate"] = V;
+    }
+
+    get onrejectionhandled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onrejectionhandled"]);
+    }
+
+    set onrejectionhandled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onrejectionhandled"] = V;
+    }
+
+    get onstorage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onstorage"]);
+    }
+
+    set onstorage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onstorage"] = V;
+    }
+
+    get onunhandledrejection() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onunhandledrejection"]);
+    }
+
+    set onunhandledrejection(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onunhandledrejection"] = V;
+    }
+
+    get onunload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onunload"]);
+    }
+
+    set onunload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onunload"] = V;
+    }
+  }
+  Object.defineProperties(HTMLBodyElement.prototype, {
+    text: { enumerable: true },
+    link: { enumerable: true },
+    vLink: { enumerable: true },
+    aLink: { enumerable: true },
+    bgColor: { enumerable: true },
+    background: { 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: "HTMLBodyElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLBodyElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLBodyElement
+  });
+};
+
+const Impl = require("../nodes/HTMLBodyElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLButtonElement.js b/lib/jsdom/living/generated/HTMLButtonElement.js
new file mode 100644
index 0000000..68cf0d5
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLButtonElement.js
@@ -0,0 +1,436 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLButtonElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLButtonElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLButtonElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLButtonElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLButtonElement before HTMLElement");
+  }
+  class HTMLButtonElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLButtonElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLButtonElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    get autofocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "autofocus");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autofocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'autofocus' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "autofocus", "");
+        } else {
+          this[impl].removeAttributeNS(null, "autofocus");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get formNoValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "formnovalidate");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set formNoValidate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'formNoValidate' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "formnovalidate", "");
+        } else {
+          this[impl].removeAttributeNS(null, "formnovalidate");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get formTarget() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "formtarget");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set formTarget(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'formTarget' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "formtarget", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["type"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["type"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "value");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLButtonElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "value", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["validity"]);
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+  }
+  Object.defineProperties(HTMLButtonElement.prototype, {
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    autofocus: { enumerable: true },
+    disabled: { enumerable: true },
+    form: { enumerable: true },
+    formNoValidate: { enumerable: true },
+    formTarget: { enumerable: true },
+    name: { enumerable: true },
+    type: { enumerable: true },
+    value: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    labels: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLButtonElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLButtonElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLButtonElement
+  });
+};
+
+const Impl = require("../nodes/HTMLButtonElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLCanvasElement.js b/lib/jsdom/living/generated/HTMLCanvasElement.js
new file mode 100644
index 0000000..091435a
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLCanvasElement.js
@@ -0,0 +1,277 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLCanvasElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLCanvasElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLCanvasElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLCanvasElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLCanvasElement before HTMLElement");
+  }
+  class HTMLCanvasElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    getContext(contextId) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getContext' on 'HTMLCanvasElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getContext' on 'HTMLCanvasElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      for (let i = 1; i < arguments.length; i++) {
+        let curArg = arguments[i];
+        curArg = conversions["any"](curArg, {
+          context: "Failed to execute 'getContext' on 'HTMLCanvasElement': parameter " + (i + 1)
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getContext(...args));
+    }
+
+    toDataURL() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'toDataURL' on 'HTMLCanvasElement': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["any"](curArg, {
+            context: "Failed to execute 'toDataURL' on 'HTMLCanvasElement': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].toDataURL(...args);
+    }
+
+    toBlob(callback) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'toBlob' on 'HTMLCanvasElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = utils.tryImplForWrapper(curArg);
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'toBlob' on 'HTMLCanvasElement': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["any"](curArg, {
+            context: "Failed to execute 'toBlob' on 'HTMLCanvasElement': parameter 3"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].toBlob(...args);
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["width"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'width' property on 'HTMLCanvasElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["width"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["height"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'height' property on 'HTMLCanvasElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["height"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLCanvasElement.prototype, {
+    getContext: { enumerable: true },
+    toDataURL: { enumerable: true },
+    toBlob: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLCanvasElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLCanvasElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLCanvasElement
+  });
+};
+
+const Impl = require("../nodes/HTMLCanvasElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLCollection.js b/lib/jsdom/living/generated/HTMLCollection.js
new file mode 100644
index 0000000..2ebc879
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLCollection.js
@@ -0,0 +1,354 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "HTMLCollection";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLCollection'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLCollection"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLCollection is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class HTMLCollection {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'HTMLCollection': 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 'HTMLCollection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    namedItem(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'namedItem' on 'HTMLCollection': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'namedItem' on 'HTMLCollection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].namedItem(...args));
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+  }
+  Object.defineProperties(HTMLCollection.prototype, {
+    item: { enumerable: true },
+    namedItem: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLCollection", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLCollection;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLCollection
+  });
+};
+
+const proxyHandler = {
+  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[impl][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of target[impl][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;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    const namedValue = target[impl].namedItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: false,
+        enumerable: false,
+        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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+
+      typeof P === "string" && !utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+    if (!utils.hasOwn(target, P)) {
+      const creating = !(target[impl].namedItem(P) !== null);
+      if (!creating) {
+        return false;
+      }
+    }
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    if (target[impl].namedItem(P) !== null && !(P in target)) {
+      return false;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../nodes/HTMLCollection-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDListElement.js b/lib/jsdom/living/generated/HTMLDListElement.js
new file mode 100644
index 0000000..1fd4e05
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDListElement.js
@@ -0,0 +1,152 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDListElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDListElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDListElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDListElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDListElement before HTMLElement");
+  }
+  class HTMLDListElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get compact() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "compact");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set compact(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'compact' property on 'HTMLDListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "compact", "");
+        } else {
+          this[impl].removeAttributeNS(null, "compact");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLDListElement.prototype, {
+    compact: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDListElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDListElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDListElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDListElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDataElement.js b/lib/jsdom/living/generated/HTMLDataElement.js
new file mode 100644
index 0000000..cd8a7f3
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDataElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDataElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDataElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDataElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDataElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDataElement before HTMLElement");
+  }
+  class HTMLDataElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "value");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLDataElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "value", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLDataElement.prototype, {
+    value: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDataElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDataElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDataElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDataElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDataListElement.js b/lib/jsdom/living/generated/HTMLDataListElement.js
new file mode 100644
index 0000000..2bdc023
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDataListElement.js
@@ -0,0 +1,126 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDataListElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDataListElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDataListElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDataListElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDataListElement before HTMLElement");
+  }
+  class HTMLDataListElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get options() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "options", () => {
+        return utils.tryWrapperForImpl(this[impl]["options"]);
+      });
+    }
+  }
+  Object.defineProperties(HTMLDataListElement.prototype, {
+    options: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDataListElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDataListElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDataListElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDataListElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDetailsElement.js b/lib/jsdom/living/generated/HTMLDetailsElement.js
new file mode 100644
index 0000000..10f28a8
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDetailsElement.js
@@ -0,0 +1,152 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDetailsElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDetailsElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDetailsElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDetailsElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDetailsElement before HTMLElement");
+  }
+  class HTMLDetailsElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get open() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "open");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set open(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'open' property on 'HTMLDetailsElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "open", "");
+        } else {
+          this[impl].removeAttributeNS(null, "open");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLDetailsElement.prototype, {
+    open: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDetailsElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDetailsElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDetailsElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDetailsElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDialogElement.js b/lib/jsdom/living/generated/HTMLDialogElement.js
new file mode 100644
index 0000000..ee6b310
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDialogElement.js
@@ -0,0 +1,152 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDialogElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDialogElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDialogElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDialogElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDialogElement before HTMLElement");
+  }
+  class HTMLDialogElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get open() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "open");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set open(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'open' property on 'HTMLDialogElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "open", "");
+        } else {
+          this[impl].removeAttributeNS(null, "open");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLDialogElement.prototype, {
+    open: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDialogElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDialogElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDialogElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDialogElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDirectoryElement.js b/lib/jsdom/living/generated/HTMLDirectoryElement.js
new file mode 100644
index 0000000..5d1dccb
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDirectoryElement.js
@@ -0,0 +1,152 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDirectoryElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDirectoryElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDirectoryElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDirectoryElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDirectoryElement before HTMLElement");
+  }
+  class HTMLDirectoryElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get compact() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "compact");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set compact(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'compact' property on 'HTMLDirectoryElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "compact", "");
+        } else {
+          this[impl].removeAttributeNS(null, "compact");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLDirectoryElement.prototype, {
+    compact: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDirectoryElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDirectoryElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDirectoryElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDirectoryElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLDivElement.js b/lib/jsdom/living/generated/HTMLDivElement.js
new file mode 100644
index 0000000..6914b24
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLDivElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLDivElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLDivElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLDivElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLDivElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLDivElement before HTMLElement");
+  }
+  class HTMLDivElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLDivElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLDivElement.prototype, {
+    align: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLDivElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLDivElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLDivElement
+  });
+};
+
+const Impl = require("../nodes/HTMLDivElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLElement.js b/lib/jsdom/living/generated/HTMLElement.js
new file mode 100644
index 0000000..8ab94ad
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLElement.js
@@ -0,0 +1,1658 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Element = require("./Element.js");
+
+const interfaceName = "HTMLElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Element._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Element === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLElement before Element");
+  }
+  class HTMLElement extends globalObject.Element {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    click() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].click();
+    }
+
+    focus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].focus();
+    }
+
+    blur() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].blur();
+    }
+
+    get title() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "title");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set title(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'title' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "title", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get lang() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "lang");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set lang(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'lang' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "lang", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get translate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["translate"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set translate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'translate' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["translate"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get dir() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["dir"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set dir(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'dir' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["dir"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hidden() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "hidden");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hidden(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'hidden' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "hidden", "");
+        } else {
+          this[impl].removeAttributeNS(null, "hidden");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get accessKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "accesskey");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set accessKey(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'accessKey' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "accesskey", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get draggable() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["draggable"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set draggable(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'draggable' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["draggable"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get offsetParent() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["offsetParent"]);
+    }
+
+    get offsetTop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["offsetTop"];
+    }
+
+    get offsetLeft() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["offsetLeft"];
+    }
+
+    get offsetWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["offsetWidth"];
+    }
+
+    get offsetHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["offsetHeight"];
+    }
+
+    get style() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "style", () => {
+        return utils.tryWrapperForImpl(this[impl]["style"]);
+      });
+    }
+
+    set style(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.style.cssText = V;
+    }
+
+    get onabort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onabort"]);
+    }
+
+    set onabort(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onabort"] = V;
+    }
+
+    get onauxclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onauxclick"]);
+    }
+
+    set onauxclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onauxclick"] = V;
+    }
+
+    get onblur() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onblur"]);
+    }
+
+    set onblur(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onblur"] = V;
+    }
+
+    get oncancel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncancel"]);
+    }
+
+    set oncancel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncancel"] = V;
+    }
+
+    get oncanplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncanplay"]);
+    }
+
+    set oncanplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncanplay"] = V;
+    }
+
+    get oncanplaythrough() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncanplaythrough"]);
+    }
+
+    set oncanplaythrough(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncanplaythrough"] = V;
+    }
+
+    get onchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onchange"]);
+    }
+
+    set onchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onchange"] = V;
+    }
+
+    get onclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclick"]);
+    }
+
+    set onclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclick"] = V;
+    }
+
+    get onclose() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclose"]);
+    }
+
+    set onclose(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclose"] = V;
+    }
+
+    get oncontextmenu() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncontextmenu"]);
+    }
+
+    set oncontextmenu(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncontextmenu"] = V;
+    }
+
+    get oncuechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncuechange"]);
+    }
+
+    set oncuechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncuechange"] = V;
+    }
+
+    get ondblclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondblclick"]);
+    }
+
+    set ondblclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondblclick"] = V;
+    }
+
+    get ondrag() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondrag"]);
+    }
+
+    set ondrag(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondrag"] = V;
+    }
+
+    get ondragend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragend"]);
+    }
+
+    set ondragend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragend"] = V;
+    }
+
+    get ondragenter() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragenter"]);
+    }
+
+    set ondragenter(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragenter"] = V;
+    }
+
+    get ondragexit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragexit"]);
+    }
+
+    set ondragexit(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragexit"] = V;
+    }
+
+    get ondragleave() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragleave"]);
+    }
+
+    set ondragleave(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragleave"] = V;
+    }
+
+    get ondragover() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragover"]);
+    }
+
+    set ondragover(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragover"] = V;
+    }
+
+    get ondragstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragstart"]);
+    }
+
+    set ondragstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragstart"] = V;
+    }
+
+    get ondrop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondrop"]);
+    }
+
+    set ondrop(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondrop"] = V;
+    }
+
+    get ondurationchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondurationchange"]);
+    }
+
+    set ondurationchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondurationchange"] = V;
+    }
+
+    get onemptied() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onemptied"]);
+    }
+
+    set onemptied(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onemptied"] = V;
+    }
+
+    get onended() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onended"]);
+    }
+
+    set onended(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onended"] = V;
+    }
+
+    get onerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onerror"]);
+    }
+
+    set onerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onerror"] = V;
+    }
+
+    get onfocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onfocus"]);
+    }
+
+    set onfocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onfocus"] = V;
+    }
+
+    get oninput() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oninput"]);
+    }
+
+    set oninput(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oninput"] = V;
+    }
+
+    get oninvalid() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oninvalid"]);
+    }
+
+    set oninvalid(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oninvalid"] = V;
+    }
+
+    get onkeydown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeydown"]);
+    }
+
+    set onkeydown(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeydown"] = V;
+    }
+
+    get onkeypress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeypress"]);
+    }
+
+    set onkeypress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeypress"] = V;
+    }
+
+    get onkeyup() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeyup"]);
+    }
+
+    set onkeyup(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeyup"] = V;
+    }
+
+    get onload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onload"]);
+    }
+
+    set onload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onload"] = V;
+    }
+
+    get onloadeddata() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadeddata"]);
+    }
+
+    set onloadeddata(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadeddata"] = V;
+    }
+
+    get onloadedmetadata() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadedmetadata"]);
+    }
+
+    set onloadedmetadata(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadedmetadata"] = V;
+    }
+
+    get onloadend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadend"]);
+    }
+
+    set onloadend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadend"] = V;
+    }
+
+    get onloadstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadstart"]);
+    }
+
+    set onloadstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadstart"] = V;
+    }
+
+    get onmousedown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmousedown"]);
+    }
+
+    set onmousedown(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmousedown"] = V;
+    }
+
+    get onmouseenter() {
+      return utils.tryWrapperForImpl(this[impl]["onmouseenter"]);
+    }
+
+    set onmouseenter(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseenter"] = V;
+    }
+
+    get onmouseleave() {
+      return utils.tryWrapperForImpl(this[impl]["onmouseleave"]);
+    }
+
+    set onmouseleave(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseleave"] = V;
+    }
+
+    get onmousemove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmousemove"]);
+    }
+
+    set onmousemove(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmousemove"] = V;
+    }
+
+    get onmouseout() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseout"]);
+    }
+
+    set onmouseout(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseout"] = V;
+    }
+
+    get onmouseover() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseover"]);
+    }
+
+    set onmouseover(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseover"] = V;
+    }
+
+    get onmouseup() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseup"]);
+    }
+
+    set onmouseup(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseup"] = V;
+    }
+
+    get onwheel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onwheel"]);
+    }
+
+    set onwheel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onwheel"] = V;
+    }
+
+    get onpause() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpause"]);
+    }
+
+    set onpause(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpause"] = V;
+    }
+
+    get onplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onplay"]);
+    }
+
+    set onplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onplay"] = V;
+    }
+
+    get onplaying() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onplaying"]);
+    }
+
+    set onplaying(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onplaying"] = V;
+    }
+
+    get onprogress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onprogress"]);
+    }
+
+    set onprogress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onprogress"] = V;
+    }
+
+    get onratechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onratechange"]);
+    }
+
+    set onratechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onratechange"] = V;
+    }
+
+    get onreset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onreset"]);
+    }
+
+    set onreset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onreset"] = V;
+    }
+
+    get onresize() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onresize"]);
+    }
+
+    set onresize(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onresize"] = V;
+    }
+
+    get onscroll() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onscroll"]);
+    }
+
+    set onscroll(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onscroll"] = V;
+    }
+
+    get onsecuritypolicyviolation() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsecuritypolicyviolation"]);
+    }
+
+    set onsecuritypolicyviolation(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsecuritypolicyviolation"] = V;
+    }
+
+    get onseeked() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onseeked"]);
+    }
+
+    set onseeked(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onseeked"] = V;
+    }
+
+    get onseeking() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onseeking"]);
+    }
+
+    set onseeking(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onseeking"] = V;
+    }
+
+    get onselect() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onselect"]);
+    }
+
+    set onselect(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onselect"] = V;
+    }
+
+    get onstalled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onstalled"]);
+    }
+
+    set onstalled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onstalled"] = V;
+    }
+
+    get onsubmit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsubmit"]);
+    }
+
+    set onsubmit(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsubmit"] = V;
+    }
+
+    get onsuspend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsuspend"]);
+    }
+
+    set onsuspend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsuspend"] = V;
+    }
+
+    get ontimeupdate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontimeupdate"]);
+    }
+
+    set ontimeupdate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontimeupdate"] = V;
+    }
+
+    get ontoggle() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontoggle"]);
+    }
+
+    set ontoggle(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontoggle"] = V;
+    }
+
+    get onvolumechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onvolumechange"]);
+    }
+
+    set onvolumechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onvolumechange"] = V;
+    }
+
+    get onwaiting() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onwaiting"]);
+    }
+
+    set onwaiting(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onwaiting"] = V;
+    }
+
+    get dataset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "dataset", () => {
+        return utils.tryWrapperForImpl(this[impl]["dataset"]);
+      });
+    }
+
+    get nonce() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      const value = this[impl].getAttributeNS(null, "nonce");
+      return value === null ? "" : value;
+    }
+
+    set nonce(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'nonce' property on 'HTMLElement': The provided value"
+      });
+
+      this[impl].setAttributeNS(null, "nonce", V);
+    }
+
+    get tabIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["tabIndex"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set tabIndex(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'tabIndex' property on 'HTMLElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["tabIndex"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLElement.prototype, {
+    click: { enumerable: true },
+    focus: { enumerable: true },
+    blur: { enumerable: true },
+    title: { enumerable: true },
+    lang: { enumerable: true },
+    translate: { enumerable: true },
+    dir: { enumerable: true },
+    hidden: { enumerable: true },
+    accessKey: { enumerable: true },
+    draggable: { enumerable: true },
+    offsetParent: { enumerable: true },
+    offsetTop: { enumerable: true },
+    offsetLeft: { enumerable: true },
+    offsetWidth: { enumerable: true },
+    offsetHeight: { enumerable: true },
+    style: { enumerable: true },
+    onabort: { enumerable: true },
+    onauxclick: { enumerable: true },
+    onblur: { enumerable: true },
+    oncancel: { enumerable: true },
+    oncanplay: { enumerable: true },
+    oncanplaythrough: { enumerable: true },
+    onchange: { enumerable: true },
+    onclick: { enumerable: true },
+    onclose: { enumerable: true },
+    oncontextmenu: { enumerable: true },
+    oncuechange: { enumerable: true },
+    ondblclick: { enumerable: true },
+    ondrag: { enumerable: true },
+    ondragend: { enumerable: true },
+    ondragenter: { enumerable: true },
+    ondragexit: { enumerable: true },
+    ondragleave: { enumerable: true },
+    ondragover: { enumerable: true },
+    ondragstart: { enumerable: true },
+    ondrop: { enumerable: true },
+    ondurationchange: { enumerable: true },
+    onemptied: { enumerable: true },
+    onended: { enumerable: true },
+    onerror: { enumerable: true },
+    onfocus: { enumerable: true },
+    oninput: { enumerable: true },
+    oninvalid: { enumerable: true },
+    onkeydown: { enumerable: true },
+    onkeypress: { enumerable: true },
+    onkeyup: { enumerable: true },
+    onload: { enumerable: true },
+    onloadeddata: { enumerable: true },
+    onloadedmetadata: { enumerable: true },
+    onloadend: { enumerable: true },
+    onloadstart: { enumerable: true },
+    onmousedown: { enumerable: true },
+    onmouseenter: { enumerable: true },
+    onmouseleave: { enumerable: true },
+    onmousemove: { enumerable: true },
+    onmouseout: { enumerable: true },
+    onmouseover: { enumerable: true },
+    onmouseup: { enumerable: true },
+    onwheel: { enumerable: true },
+    onpause: { enumerable: true },
+    onplay: { enumerable: true },
+    onplaying: { enumerable: true },
+    onprogress: { enumerable: true },
+    onratechange: { enumerable: true },
+    onreset: { enumerable: true },
+    onresize: { enumerable: true },
+    onscroll: { enumerable: true },
+    onsecuritypolicyviolation: { enumerable: true },
+    onseeked: { enumerable: true },
+    onseeking: { enumerable: true },
+    onselect: { enumerable: true },
+    onstalled: { enumerable: true },
+    onsubmit: { enumerable: true },
+    onsuspend: { enumerable: true },
+    ontimeupdate: { enumerable: true },
+    ontoggle: { enumerable: true },
+    onvolumechange: { enumerable: true },
+    onwaiting: { enumerable: true },
+    dataset: { enumerable: true },
+    nonce: { enumerable: true },
+    tabIndex: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLElement
+  });
+};
+
+const Impl = require("../nodes/HTMLElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLEmbedElement.js b/lib/jsdom/living/generated/HTMLEmbedElement.js
new file mode 100644
index 0000000..eb5fd55
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLEmbedElement.js
@@ -0,0 +1,308 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLEmbedElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLEmbedElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLEmbedElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLEmbedElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLEmbedElement before HTMLElement");
+  }
+  class HTMLEmbedElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLEmbedElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLEmbedElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLEmbedElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "height");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'height' property on 'HTMLEmbedElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "height", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLEmbedElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLEmbedElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLEmbedElement.prototype, {
+    src: { enumerable: true },
+    type: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    align: { enumerable: true },
+    name: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLEmbedElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLEmbedElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLEmbedElement
+  });
+};
+
+const Impl = require("../nodes/HTMLEmbedElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLFieldSetElement.js b/lib/jsdom/living/generated/HTMLFieldSetElement.js
new file mode 100644
index 0000000..dd7c2cf
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLFieldSetElement.js
@@ -0,0 +1,284 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLFieldSetElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLFieldSetElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLFieldSetElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLFieldSetElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLFieldSetElement before HTMLElement");
+  }
+  class HTMLFieldSetElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLFieldSetElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLFieldSetElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLFieldSetElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLFieldSetElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get elements() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "elements", () => {
+        return utils.tryWrapperForImpl(this[impl]["elements"]);
+      });
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "validity", () => {
+        return utils.tryWrapperForImpl(this[impl]["validity"]);
+      });
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+  }
+  Object.defineProperties(HTMLFieldSetElement.prototype, {
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    disabled: { enumerable: true },
+    form: { enumerable: true },
+    name: { enumerable: true },
+    type: { enumerable: true },
+    elements: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLFieldSetElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLFieldSetElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLFieldSetElement
+  });
+};
+
+const Impl = require("../nodes/HTMLFieldSetElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLFontElement.js b/lib/jsdom/living/generated/HTMLFontElement.js
new file mode 100644
index 0000000..19791cb
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLFontElement.js
@@ -0,0 +1,214 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLFontElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLFontElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLFontElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLFontElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLFontElement before HTMLElement");
+  }
+  class HTMLFontElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get color() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "color");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set color(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'color' property on 'HTMLFontElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "color", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get face() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "face");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set face(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'face' property on 'HTMLFontElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "face", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get size() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "size");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set size(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'size' property on 'HTMLFontElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "size", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLFontElement.prototype, {
+    color: { enumerable: true },
+    face: { enumerable: true },
+    size: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLFontElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLFontElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLFontElement
+  });
+};
+
+const Impl = require("../nodes/HTMLFontElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLFormElement.js b/lib/jsdom/living/generated/HTMLFormElement.js
new file mode 100644
index 0000000..4f308aa
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLFormElement.js
@@ -0,0 +1,421 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const convertHTMLElement = require("./HTMLElement.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLFormElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLFormElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLFormElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLFormElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLFormElement before HTMLElement");
+  }
+  class HTMLFormElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    submit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].submit();
+    }
+
+    requestSubmit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = convertHTMLElement(curArg, {
+            context: "Failed to execute 'requestSubmit' on 'HTMLFormElement': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].requestSubmit(...args);
+    }
+
+    reset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].reset();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    get acceptCharset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "accept-charset");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set acceptCharset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'acceptCharset' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "accept-charset", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get action() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["action"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set action(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'action' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["action"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get enctype() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["enctype"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set enctype(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'enctype' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["enctype"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get method() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["method"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set method(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'method' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["method"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get noValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "novalidate");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set noValidate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'noValidate' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "novalidate", "");
+        } else {
+          this[impl].removeAttributeNS(null, "novalidate");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "target");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set target(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'target' property on 'HTMLFormElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "target", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get elements() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "elements", () => {
+        return utils.tryWrapperForImpl(this[impl]["elements"]);
+      });
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+  }
+  Object.defineProperties(HTMLFormElement.prototype, {
+    submit: { enumerable: true },
+    requestSubmit: { enumerable: true },
+    reset: { enumerable: true },
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    acceptCharset: { enumerable: true },
+    action: { enumerable: true },
+    enctype: { enumerable: true },
+    method: { enumerable: true },
+    name: { enumerable: true },
+    noValidate: { enumerable: true },
+    target: { enumerable: true },
+    elements: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLFormElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLFormElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLFormElement
+  });
+};
+
+const Impl = require("../nodes/HTMLFormElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLFrameElement.js b/lib/jsdom/living/generated/HTMLFrameElement.js
new file mode 100644
index 0000000..92ab22d
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLFrameElement.js
@@ -0,0 +1,394 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLFrameElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLFrameElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLFrameElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLFrameElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLFrameElement before HTMLElement");
+  }
+  class HTMLFrameElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get scrolling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "scrolling");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set scrolling(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'scrolling' property on 'HTMLFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "scrolling", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get frameBorder() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "frameborder");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set frameBorder(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'frameBorder' property on 'HTMLFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "frameborder", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get longDesc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["longDesc"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set longDesc(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'longDesc' property on 'HTMLFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["longDesc"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get noResize() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "noresize");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set noResize(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'noResize' property on 'HTMLFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "noresize", "");
+        } else {
+          this[impl].removeAttributeNS(null, "noresize");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get contentDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["contentDocument"]);
+    }
+
+    get contentWindow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["contentWindow"]);
+    }
+
+    get marginHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "marginheight");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set marginHeight(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'marginHeight' property on 'HTMLFrameElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "marginheight", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get marginWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "marginwidth");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set marginWidth(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'marginWidth' property on 'HTMLFrameElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "marginwidth", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLFrameElement.prototype, {
+    name: { enumerable: true },
+    scrolling: { enumerable: true },
+    src: { enumerable: true },
+    frameBorder: { enumerable: true },
+    longDesc: { enumerable: true },
+    noResize: { enumerable: true },
+    contentDocument: { enumerable: true },
+    contentWindow: { enumerable: true },
+    marginHeight: { enumerable: true },
+    marginWidth: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLFrameElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLFrameElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLFrameElement
+  });
+};
+
+const Impl = require("../nodes/HTMLFrameElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLFrameSetElement.js b/lib/jsdom/living/generated/HTMLFrameSetElement.js
new file mode 100644
index 0000000..c75d7bb
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLFrameSetElement.js
@@ -0,0 +1,485 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLFrameSetElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLFrameSetElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLFrameSetElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLFrameSetElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLFrameSetElement before HTMLElement");
+  }
+  class HTMLFrameSetElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get cols() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "cols");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set cols(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'cols' property on 'HTMLFrameSetElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "cols", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rows() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rows");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rows(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rows' property on 'HTMLFrameSetElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rows", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get onafterprint() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onafterprint"]);
+    }
+
+    set onafterprint(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onafterprint"] = V;
+    }
+
+    get onbeforeprint() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onbeforeprint"]);
+    }
+
+    set onbeforeprint(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onbeforeprint"] = V;
+    }
+
+    get onbeforeunload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onbeforeunload"]);
+    }
+
+    set onbeforeunload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onbeforeunload"] = V;
+    }
+
+    get onhashchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onhashchange"]);
+    }
+
+    set onhashchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onhashchange"] = V;
+    }
+
+    get onlanguagechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onlanguagechange"]);
+    }
+
+    set onlanguagechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onlanguagechange"] = V;
+    }
+
+    get onmessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessage"]);
+    }
+
+    set onmessage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessage"] = V;
+    }
+
+    get onmessageerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessageerror"]);
+    }
+
+    set onmessageerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessageerror"] = V;
+    }
+
+    get onoffline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onoffline"]);
+    }
+
+    set onoffline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onoffline"] = V;
+    }
+
+    get ononline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ononline"]);
+    }
+
+    set ononline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ononline"] = V;
+    }
+
+    get onpagehide() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpagehide"]);
+    }
+
+    set onpagehide(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpagehide"] = V;
+    }
+
+    get onpageshow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpageshow"]);
+    }
+
+    set onpageshow(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpageshow"] = V;
+    }
+
+    get onpopstate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpopstate"]);
+    }
+
+    set onpopstate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpopstate"] = V;
+    }
+
+    get onrejectionhandled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onrejectionhandled"]);
+    }
+
+    set onrejectionhandled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onrejectionhandled"] = V;
+    }
+
+    get onstorage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onstorage"]);
+    }
+
+    set onstorage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onstorage"] = V;
+    }
+
+    get onunhandledrejection() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onunhandledrejection"]);
+    }
+
+    set onunhandledrejection(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onunhandledrejection"] = V;
+    }
+
+    get onunload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onunload"]);
+    }
+
+    set onunload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onunload"] = V;
+    }
+  }
+  Object.defineProperties(HTMLFrameSetElement.prototype, {
+    cols: { enumerable: true },
+    rows: { 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: "HTMLFrameSetElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLFrameSetElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLFrameSetElement
+  });
+};
+
+const Impl = require("../nodes/HTMLFrameSetElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLHRElement.js b/lib/jsdom/living/generated/HTMLHRElement.js
new file mode 100644
index 0000000..e01df05
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLHRElement.js
@@ -0,0 +1,280 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLHRElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLHRElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLHRElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLHRElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLHRElement before HTMLElement");
+  }
+  class HTMLHRElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLHRElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get color() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "color");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set color(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'color' property on 'HTMLHRElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "color", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get noShade() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "noshade");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set noShade(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'noShade' property on 'HTMLHRElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "noshade", "");
+        } else {
+          this[impl].removeAttributeNS(null, "noshade");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get size() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "size");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set size(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'size' property on 'HTMLHRElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "size", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLHRElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLHRElement.prototype, {
+    align: { enumerable: true },
+    color: { enumerable: true },
+    noShade: { enumerable: true },
+    size: { enumerable: true },
+    width: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLHRElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLHRElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLHRElement
+  });
+};
+
+const Impl = require("../nodes/HTMLHRElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLHeadElement.js b/lib/jsdom/living/generated/HTMLHeadElement.js
new file mode 100644
index 0000000..c38dbd5
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLHeadElement.js
@@ -0,0 +1,115 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLHeadElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLHeadElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLHeadElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLHeadElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLHeadElement before HTMLElement");
+  }
+  class HTMLHeadElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+  }
+  Object.defineProperties(HTMLHeadElement.prototype, {
+    [Symbol.toStringTag]: { value: "HTMLHeadElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLHeadElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLHeadElement
+  });
+};
+
+const Impl = require("../nodes/HTMLHeadElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLHeadingElement.js b/lib/jsdom/living/generated/HTMLHeadingElement.js
new file mode 100644
index 0000000..005603e
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLHeadingElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLHeadingElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLHeadingElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLHeadingElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLHeadingElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLHeadingElement before HTMLElement");
+  }
+  class HTMLHeadingElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLHeadingElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLHeadingElement.prototype, {
+    align: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLHeadingElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLHeadingElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLHeadingElement
+  });
+};
+
+const Impl = require("../nodes/HTMLHeadingElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLHtmlElement.js b/lib/jsdom/living/generated/HTMLHtmlElement.js
new file mode 100644
index 0000000..73ecb51
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLHtmlElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLHtmlElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLHtmlElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLHtmlElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLHtmlElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLHtmlElement before HTMLElement");
+  }
+  class HTMLHtmlElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get version() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "version");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set version(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'version' property on 'HTMLHtmlElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "version", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLHtmlElement.prototype, {
+    version: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLHtmlElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLHtmlElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLHtmlElement
+  });
+};
+
+const Impl = require("../nodes/HTMLHtmlElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLIFrameElement.js b/lib/jsdom/living/generated/HTMLIFrameElement.js
new file mode 100644
index 0000000..c2b315e
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLIFrameElement.js
@@ -0,0 +1,531 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLIFrameElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLIFrameElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLIFrameElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLIFrameElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLIFrameElement before HTMLElement");
+  }
+  class HTMLIFrameElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    getSVGDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].getSVGDocument());
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get srcdoc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "srcdoc");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set srcdoc(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'srcdoc' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "srcdoc", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get allowFullscreen() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "allowfullscreen");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set allowFullscreen(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'allowFullscreen' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "allowfullscreen", "");
+        } else {
+          this[impl].removeAttributeNS(null, "allowfullscreen");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "height");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'height' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "height", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get contentDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["contentDocument"]);
+    }
+
+    get contentWindow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["contentWindow"]);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get scrolling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "scrolling");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set scrolling(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'scrolling' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "scrolling", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get frameBorder() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "frameborder");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set frameBorder(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'frameBorder' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "frameborder", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get longDesc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["longDesc"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set longDesc(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'longDesc' property on 'HTMLIFrameElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["longDesc"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get marginHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "marginheight");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set marginHeight(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'marginHeight' property on 'HTMLIFrameElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "marginheight", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get marginWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "marginwidth");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set marginWidth(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'marginWidth' property on 'HTMLIFrameElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "marginwidth", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLIFrameElement.prototype, {
+    getSVGDocument: { enumerable: true },
+    src: { enumerable: true },
+    srcdoc: { enumerable: true },
+    name: { enumerable: true },
+    allowFullscreen: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    contentDocument: { enumerable: true },
+    contentWindow: { enumerable: true },
+    align: { enumerable: true },
+    scrolling: { enumerable: true },
+    frameBorder: { enumerable: true },
+    longDesc: { enumerable: true },
+    marginHeight: { enumerable: true },
+    marginWidth: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLIFrameElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLIFrameElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLIFrameElement
+  });
+};
+
+const Impl = require("../nodes/HTMLIFrameElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLImageElement.js b/lib/jsdom/living/generated/HTMLImageElement.js
new file mode 100644
index 0000000..84b0498
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLImageElement.js
@@ -0,0 +1,667 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLImageElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLImageElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLImageElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLImageElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLImageElement before HTMLElement");
+  }
+  class HTMLImageElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get alt() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "alt");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set alt(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'alt' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "alt", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get srcset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["srcset"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set srcset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'srcset' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["srcset"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get sizes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "sizes");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set sizes(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'sizes' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "sizes", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get crossOrigin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "crossorigin");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set crossOrigin(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'crossOrigin' property on 'HTMLImageElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "crossorigin", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get useMap() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "usemap");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set useMap(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'useMap' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "usemap", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get isMap() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "ismap");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set isMap(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'isMap' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "ismap", "");
+        } else {
+          this[impl].removeAttributeNS(null, "ismap");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["width"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'width' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["width"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["height"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'height' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["height"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get naturalWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["naturalWidth"];
+    }
+
+    get naturalHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["naturalHeight"];
+    }
+
+    get complete() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["complete"];
+    }
+
+    get currentSrc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["currentSrc"];
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get lowsrc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["lowsrc"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set lowsrc(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'lowsrc' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["lowsrc"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hspace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "hspace"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hspace(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'hspace' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "hspace", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vspace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "vspace"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vspace(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'vspace' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "vspace", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get longDesc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["longDesc"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set longDesc(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'longDesc' property on 'HTMLImageElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["longDesc"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get border() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "border");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set border(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'border' property on 'HTMLImageElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "border", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLImageElement.prototype, {
+    alt: { enumerable: true },
+    src: { enumerable: true },
+    srcset: { enumerable: true },
+    sizes: { enumerable: true },
+    crossOrigin: { enumerable: true },
+    useMap: { enumerable: true },
+    isMap: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    naturalWidth: { enumerable: true },
+    naturalHeight: { enumerable: true },
+    complete: { enumerable: true },
+    currentSrc: { enumerable: true },
+    name: { enumerable: true },
+    lowsrc: { enumerable: true },
+    align: { enumerable: true },
+    hspace: { enumerable: true },
+    vspace: { enumerable: true },
+    longDesc: { enumerable: true },
+    border: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLImageElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLImageElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLImageElement
+  });
+};
+
+const Impl = require("../nodes/HTMLImageElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLInputElement.js b/lib/jsdom/living/generated/HTMLInputElement.js
new file mode 100644
index 0000000..059436f
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLInputElement.js
@@ -0,0 +1,1488 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const convertSelectionMode = require("./SelectionMode.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const convertFileList = require("./FileList.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLInputElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLInputElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLInputElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLInputElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLInputElement before HTMLElement");
+  }
+  class HTMLInputElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    stepUp() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'stepUp' on 'HTMLInputElement': parameter 1"
+          });
+        } else {
+          curArg = 1;
+        }
+        args.push(curArg);
+      }
+      return this[impl].stepUp(...args);
+    }
+
+    stepDown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'stepDown' on 'HTMLInputElement': parameter 1"
+          });
+        } else {
+          curArg = 1;
+        }
+        args.push(curArg);
+      }
+      return this[impl].stepDown(...args);
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLInputElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLInputElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    select() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].select();
+    }
+
+    setRangeText(replacement) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setRangeText' on 'HTMLInputElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      switch (arguments.length) {
+        case 1:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 1"
+            });
+            args.push(curArg);
+          }
+          break;
+        case 2:
+          throw new TypeError(
+            "Failed to execute 'setRangeText' on 'HTMLInputElement': only " + arguments.length + " arguments present."
+          );
+          break;
+        case 3:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 3"
+            });
+            args.push(curArg);
+          }
+          break;
+        default:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 3"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[3];
+            if (curArg !== undefined) {
+              curArg = convertSelectionMode(curArg, {
+                context: "Failed to execute 'setRangeText' on 'HTMLInputElement': parameter 4"
+              });
+            } else {
+              curArg = "preserve";
+            }
+            args.push(curArg);
+          }
+      }
+      return this[impl].setRangeText(...args);
+    }
+
+    setSelectionRange(start, end) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'setSelectionRange' on 'HTMLInputElement': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setSelectionRange' on 'HTMLInputElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setSelectionRange' on 'HTMLInputElement': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'setSelectionRange' on 'HTMLInputElement': parameter 3"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].setSelectionRange(...args);
+    }
+
+    get accept() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "accept");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set accept(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'accept' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "accept", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get alt() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "alt");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set alt(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'alt' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "alt", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get autocomplete() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "autocomplete");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autocomplete(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'autocomplete' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "autocomplete", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get autofocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "autofocus");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autofocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'autofocus' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "autofocus", "");
+        } else {
+          this[impl].removeAttributeNS(null, "autofocus");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get defaultChecked() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "checked");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defaultChecked(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'defaultChecked' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "checked", "");
+        } else {
+          this[impl].removeAttributeNS(null, "checked");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get checked() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["checked"];
+    }
+
+    set checked(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'checked' property on 'HTMLInputElement': The provided value"
+      });
+
+      this[impl]["checked"] = V;
+    }
+
+    get dirName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "dirname");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set dirName(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'dirName' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "dirname", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get files() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["files"]);
+    }
+
+    set files(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = convertFileList(V, {
+          context: "Failed to set the 'files' property on 'HTMLInputElement': The provided value"
+        });
+      }
+      this[impl]["files"] = V;
+    }
+
+    get formNoValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "formnovalidate");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set formNoValidate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'formNoValidate' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "formnovalidate", "");
+        } else {
+          this[impl].removeAttributeNS(null, "formnovalidate");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get formTarget() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "formtarget");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set formTarget(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'formTarget' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "formtarget", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get indeterminate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["indeterminate"];
+    }
+
+    set indeterminate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'indeterminate' property on 'HTMLInputElement': The provided value"
+      });
+
+      this[impl]["indeterminate"] = V;
+    }
+
+    get inputMode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "inputmode");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set inputMode(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'inputMode' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "inputmode", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get list() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["list"]);
+    }
+
+    get max() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "max");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set max(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'max' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "max", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get maxLength() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["maxLength"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set maxLength(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'maxLength' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["maxLength"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get min() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "min");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set min(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'min' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "min", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get minLength() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["minLength"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set minLength(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'minLength' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["minLength"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get multiple() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "multiple");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set multiple(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'multiple' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "multiple", "");
+        } else {
+          this[impl].removeAttributeNS(null, "multiple");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get pattern() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "pattern");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set pattern(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'pattern' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "pattern", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get placeholder() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "placeholder");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set placeholder(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'placeholder' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "placeholder", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get readOnly() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "readonly");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set readOnly(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'readOnly' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "readonly", "");
+        } else {
+          this[impl].removeAttributeNS(null, "readonly");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get required() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "required");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set required(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'required' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "required", "");
+        } else {
+          this[impl].removeAttributeNS(null, "required");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get size() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["size"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set size(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'size' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["size"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get step() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "step");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set step(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'step' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "step", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["type"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["type"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get defaultValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "value");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defaultValue(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'defaultValue' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "value", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLInputElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get valueAsDate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["valueAsDate"];
+    }
+
+    set valueAsDate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["object"](V, {
+          context: "Failed to set the 'valueAsDate' property on 'HTMLInputElement': The provided value"
+        });
+      }
+      this[impl]["valueAsDate"] = V;
+    }
+
+    get valueAsNumber() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["valueAsNumber"];
+    }
+
+    set valueAsNumber(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unrestricted double"](V, {
+        context: "Failed to set the 'valueAsNumber' property on 'HTMLInputElement': The provided value"
+      });
+
+      this[impl]["valueAsNumber"] = V;
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["validity"]);
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+
+    get selectionStart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectionStart"];
+    }
+
+    set selectionStart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["unsigned long"](V, {
+          context: "Failed to set the 'selectionStart' property on 'HTMLInputElement': The provided value"
+        });
+      }
+      this[impl]["selectionStart"] = V;
+    }
+
+    get selectionEnd() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectionEnd"];
+    }
+
+    set selectionEnd(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["unsigned long"](V, {
+          context: "Failed to set the 'selectionEnd' property on 'HTMLInputElement': The provided value"
+        });
+      }
+      this[impl]["selectionEnd"] = V;
+    }
+
+    get selectionDirection() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectionDirection"];
+    }
+
+    set selectionDirection(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'selectionDirection' property on 'HTMLInputElement': The provided value"
+        });
+      }
+      this[impl]["selectionDirection"] = V;
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get useMap() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "usemap");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set useMap(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'useMap' property on 'HTMLInputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "usemap", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLInputElement.prototype, {
+    stepUp: { enumerable: true },
+    stepDown: { enumerable: true },
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    select: { enumerable: true },
+    setRangeText: { enumerable: true },
+    setSelectionRange: { enumerable: true },
+    accept: { enumerable: true },
+    alt: { enumerable: true },
+    autocomplete: { enumerable: true },
+    autofocus: { enumerable: true },
+    defaultChecked: { enumerable: true },
+    checked: { enumerable: true },
+    dirName: { enumerable: true },
+    disabled: { enumerable: true },
+    form: { enumerable: true },
+    files: { enumerable: true },
+    formNoValidate: { enumerable: true },
+    formTarget: { enumerable: true },
+    indeterminate: { enumerable: true },
+    inputMode: { enumerable: true },
+    list: { enumerable: true },
+    max: { enumerable: true },
+    maxLength: { enumerable: true },
+    min: { enumerable: true },
+    minLength: { enumerable: true },
+    multiple: { enumerable: true },
+    name: { enumerable: true },
+    pattern: { enumerable: true },
+    placeholder: { enumerable: true },
+    readOnly: { enumerable: true },
+    required: { enumerable: true },
+    size: { enumerable: true },
+    src: { enumerable: true },
+    step: { enumerable: true },
+    type: { enumerable: true },
+    defaultValue: { enumerable: true },
+    value: { enumerable: true },
+    valueAsDate: { enumerable: true },
+    valueAsNumber: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    labels: { enumerable: true },
+    selectionStart: { enumerable: true },
+    selectionEnd: { enumerable: true },
+    selectionDirection: { enumerable: true },
+    align: { enumerable: true },
+    useMap: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLInputElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLInputElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLInputElement
+  });
+};
+
+const Impl = require("../nodes/HTMLInputElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLLIElement.js b/lib/jsdom/living/generated/HTMLLIElement.js
new file mode 100644
index 0000000..2419f61
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLLIElement.js
@@ -0,0 +1,181 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLLIElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLLIElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLLIElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLLIElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLLIElement before HTMLElement");
+  }
+  class HTMLLIElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "value"));
+        return isNaN(value) || value < -2147483648 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'value' property on 'HTMLLIElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "value", String(V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLLIElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLLIElement.prototype, {
+    value: { enumerable: true },
+    type: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLLIElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLLIElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLLIElement
+  });
+};
+
+const Impl = require("../nodes/HTMLLIElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLLabelElement.js b/lib/jsdom/living/generated/HTMLLabelElement.js
new file mode 100644
index 0000000..f58a6b7
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLLabelElement.js
@@ -0,0 +1,167 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLLabelElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLLabelElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLLabelElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLLabelElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLLabelElement before HTMLElement");
+  }
+  class HTMLLabelElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get htmlFor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "for");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set htmlFor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'htmlFor' property on 'HTMLLabelElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "for", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get control() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["control"]);
+    }
+  }
+  Object.defineProperties(HTMLLabelElement.prototype, {
+    form: { enumerable: true },
+    htmlFor: { enumerable: true },
+    control: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLLabelElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLLabelElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLLabelElement
+  });
+};
+
+const Impl = require("../nodes/HTMLLabelElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLLegendElement.js b/lib/jsdom/living/generated/HTMLLegendElement.js
new file mode 100644
index 0000000..75385e2
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLLegendElement.js
@@ -0,0 +1,158 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLLegendElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLLegendElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLLegendElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLLegendElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLLegendElement before HTMLElement");
+  }
+  class HTMLLegendElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLLegendElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLLegendElement.prototype, {
+    form: { enumerable: true },
+    align: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLLegendElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLLegendElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLLegendElement
+  });
+};
+
+const Impl = require("../nodes/HTMLLegendElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLLinkElement.js b/lib/jsdom/living/generated/HTMLLinkElement.js
new file mode 100644
index 0000000..aa5535e
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLLinkElement.js
@@ -0,0 +1,436 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLLinkElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLLinkElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLLinkElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLLinkElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLLinkElement before HTMLElement");
+  }
+  class HTMLLinkElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get href() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["href"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set href(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'href' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["href"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get crossOrigin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "crossorigin");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set crossOrigin(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'crossOrigin' property on 'HTMLLinkElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "crossorigin", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rel");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rel' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rel", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get relList() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "relList", () => {
+        return utils.tryWrapperForImpl(this[impl]["relList"]);
+      });
+    }
+
+    set relList(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.relList.value = V;
+    }
+
+    get media() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "media");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set media(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'media' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "media", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hreflang() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "hreflang");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hreflang(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'hreflang' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "hreflang", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get charset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charset");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set charset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'charset' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charset", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rev() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rev");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rev(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rev' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rev", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "target");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set target(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'target' property on 'HTMLLinkElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "target", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get sheet() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["sheet"]);
+    }
+  }
+  Object.defineProperties(HTMLLinkElement.prototype, {
+    href: { enumerable: true },
+    crossOrigin: { enumerable: true },
+    rel: { enumerable: true },
+    relList: { enumerable: true },
+    media: { enumerable: true },
+    hreflang: { enumerable: true },
+    type: { enumerable: true },
+    charset: { enumerable: true },
+    rev: { enumerable: true },
+    target: { enumerable: true },
+    sheet: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLLinkElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLLinkElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLLinkElement
+  });
+};
+
+const Impl = require("../nodes/HTMLLinkElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLMapElement.js b/lib/jsdom/living/generated/HTMLMapElement.js
new file mode 100644
index 0000000..dbff9ba
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLMapElement.js
@@ -0,0 +1,160 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLMapElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLMapElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLMapElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLMapElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLMapElement before HTMLElement");
+  }
+  class HTMLMapElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLMapElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get areas() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "areas", () => {
+        return utils.tryWrapperForImpl(this[impl]["areas"]);
+      });
+    }
+  }
+  Object.defineProperties(HTMLMapElement.prototype, {
+    name: { enumerable: true },
+    areas: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLMapElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLMapElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLMapElement
+  });
+};
+
+const Impl = require("../nodes/HTMLMapElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLMarqueeElement.js b/lib/jsdom/living/generated/HTMLMarqueeElement.js
new file mode 100644
index 0000000..52a190b
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLMarqueeElement.js
@@ -0,0 +1,440 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLMarqueeElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLMarqueeElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLMarqueeElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLMarqueeElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLMarqueeElement before HTMLElement");
+  }
+  class HTMLMarqueeElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get behavior() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "behavior");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set behavior(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'behavior' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "behavior", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get bgColor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "bgcolor");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set bgColor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'bgColor' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "bgcolor", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get direction() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "direction");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set direction(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'direction' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "direction", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "height");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'height' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "height", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hspace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "hspace"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hspace(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'hspace' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "hspace", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get scrollAmount() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "scrollamount"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set scrollAmount(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'scrollAmount' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "scrollamount", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get scrollDelay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "scrolldelay"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set scrollDelay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'scrollDelay' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "scrolldelay", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get trueSpeed() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "truespeed");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set trueSpeed(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'trueSpeed' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "truespeed", "");
+        } else {
+          this[impl].removeAttributeNS(null, "truespeed");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vspace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "vspace"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vspace(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'vspace' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "vspace", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLMarqueeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLMarqueeElement.prototype, {
+    behavior: { enumerable: true },
+    bgColor: { enumerable: true },
+    direction: { enumerable: true },
+    height: { enumerable: true },
+    hspace: { enumerable: true },
+    scrollAmount: { enumerable: true },
+    scrollDelay: { enumerable: true },
+    trueSpeed: { enumerable: true },
+    vspace: { enumerable: true },
+    width: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLMarqueeElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLMarqueeElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLMarqueeElement
+  });
+};
+
+const Impl = require("../nodes/HTMLMarqueeElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLMediaElement.js b/lib/jsdom/living/generated/HTMLMediaElement.js
new file mode 100644
index 0000000..c4bbf43
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLMediaElement.js
@@ -0,0 +1,701 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertTextTrackKind = require("./TextTrackKind.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLMediaElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLMediaElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLMediaElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLMediaElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLMediaElement before HTMLElement");
+  }
+  class HTMLMediaElement extends globalObject.HTMLElement {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    load() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].load();
+    }
+
+    canPlayType(type) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'canPlayType' on 'HTMLMediaElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'canPlayType' on 'HTMLMediaElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].canPlayType(...args));
+    }
+
+    play() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].play());
+    }
+
+    pause() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].pause();
+    }
+
+    addTextTrack(kind) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'addTextTrack' on 'HTMLMediaElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertTextTrackKind(curArg, {
+          context: "Failed to execute 'addTextTrack' on 'HTMLMediaElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'addTextTrack' on 'HTMLMediaElement': parameter 2"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'addTextTrack' on 'HTMLMediaElement': parameter 3"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].addTextTrack(...args));
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLMediaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get currentSrc() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["currentSrc"];
+    }
+
+    get crossOrigin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "crossorigin");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set crossOrigin(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'crossOrigin' property on 'HTMLMediaElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "crossorigin", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get networkState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["networkState"];
+    }
+
+    get preload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "preload");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set preload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'preload' property on 'HTMLMediaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "preload", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get buffered() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["buffered"]);
+    }
+
+    get readyState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["readyState"];
+    }
+
+    get seeking() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["seeking"];
+    }
+
+    get currentTime() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["currentTime"];
+    }
+
+    set currentTime(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'currentTime' property on 'HTMLMediaElement': The provided value"
+      });
+
+      this[impl]["currentTime"] = V;
+    }
+
+    get duration() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["duration"];
+    }
+
+    get paused() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["paused"];
+    }
+
+    get defaultPlaybackRate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["defaultPlaybackRate"];
+    }
+
+    set defaultPlaybackRate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'defaultPlaybackRate' property on 'HTMLMediaElement': The provided value"
+      });
+
+      this[impl]["defaultPlaybackRate"] = V;
+    }
+
+    get playbackRate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["playbackRate"];
+    }
+
+    set playbackRate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'playbackRate' property on 'HTMLMediaElement': The provided value"
+      });
+
+      this[impl]["playbackRate"] = V;
+    }
+
+    get played() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["played"]);
+    }
+
+    get seekable() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["seekable"]);
+    }
+
+    get ended() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["ended"];
+    }
+
+    get autoplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "autoplay");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autoplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'autoplay' property on 'HTMLMediaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "autoplay", "");
+        } else {
+          this[impl].removeAttributeNS(null, "autoplay");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get loop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "loop");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set loop(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'loop' property on 'HTMLMediaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "loop", "");
+        } else {
+          this[impl].removeAttributeNS(null, "loop");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get controls() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "controls");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set controls(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'controls' property on 'HTMLMediaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "controls", "");
+        } else {
+          this[impl].removeAttributeNS(null, "controls");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get volume() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["volume"];
+    }
+
+    set volume(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'volume' property on 'HTMLMediaElement': The provided value"
+      });
+
+      this[impl]["volume"] = V;
+    }
+
+    get muted() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["muted"];
+    }
+
+    set muted(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'muted' property on 'HTMLMediaElement': The provided value"
+      });
+
+      this[impl]["muted"] = V;
+    }
+
+    get defaultMuted() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "muted");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defaultMuted(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'defaultMuted' property on 'HTMLMediaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "muted", "");
+        } else {
+          this[impl].removeAttributeNS(null, "muted");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get audioTracks() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "audioTracks", () => {
+        return utils.tryWrapperForImpl(this[impl]["audioTracks"]);
+      });
+    }
+
+    get videoTracks() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "videoTracks", () => {
+        return utils.tryWrapperForImpl(this[impl]["videoTracks"]);
+      });
+    }
+
+    get textTracks() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "textTracks", () => {
+        return utils.tryWrapperForImpl(this[impl]["textTracks"]);
+      });
+    }
+  }
+  Object.defineProperties(HTMLMediaElement.prototype, {
+    load: { enumerable: true },
+    canPlayType: { enumerable: true },
+    play: { enumerable: true },
+    pause: { enumerable: true },
+    addTextTrack: { enumerable: true },
+    src: { enumerable: true },
+    currentSrc: { enumerable: true },
+    crossOrigin: { enumerable: true },
+    networkState: { enumerable: true },
+    preload: { enumerable: true },
+    buffered: { enumerable: true },
+    readyState: { enumerable: true },
+    seeking: { enumerable: true },
+    currentTime: { enumerable: true },
+    duration: { enumerable: true },
+    paused: { enumerable: true },
+    defaultPlaybackRate: { enumerable: true },
+    playbackRate: { enumerable: true },
+    played: { enumerable: true },
+    seekable: { enumerable: true },
+    ended: { enumerable: true },
+    autoplay: { enumerable: true },
+    loop: { enumerable: true },
+    controls: { enumerable: true },
+    volume: { enumerable: true },
+    muted: { enumerable: true },
+    defaultMuted: { enumerable: true },
+    audioTracks: { enumerable: true },
+    videoTracks: { enumerable: true },
+    textTracks: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLMediaElement", configurable: true },
+    NETWORK_EMPTY: { value: 0, enumerable: true },
+    NETWORK_IDLE: { value: 1, enumerable: true },
+    NETWORK_LOADING: { value: 2, enumerable: true },
+    NETWORK_NO_SOURCE: { value: 3, enumerable: true },
+    HAVE_NOTHING: { value: 0, enumerable: true },
+    HAVE_METADATA: { value: 1, enumerable: true },
+    HAVE_CURRENT_DATA: { value: 2, enumerable: true },
+    HAVE_FUTURE_DATA: { value: 3, enumerable: true },
+    HAVE_ENOUGH_DATA: { value: 4, enumerable: true }
+  });
+  Object.defineProperties(HTMLMediaElement, {
+    NETWORK_EMPTY: { value: 0, enumerable: true },
+    NETWORK_IDLE: { value: 1, enumerable: true },
+    NETWORK_LOADING: { value: 2, enumerable: true },
+    NETWORK_NO_SOURCE: { value: 3, enumerable: true },
+    HAVE_NOTHING: { value: 0, enumerable: true },
+    HAVE_METADATA: { value: 1, enumerable: true },
+    HAVE_CURRENT_DATA: { value: 2, enumerable: true },
+    HAVE_FUTURE_DATA: { value: 3, enumerable: true },
+    HAVE_ENOUGH_DATA: { value: 4, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLMediaElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLMediaElement
+  });
+};
+
+const Impl = require("../nodes/HTMLMediaElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLMenuElement.js b/lib/jsdom/living/generated/HTMLMenuElement.js
new file mode 100644
index 0000000..8532c5d
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLMenuElement.js
@@ -0,0 +1,152 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLMenuElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLMenuElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLMenuElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLMenuElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLMenuElement before HTMLElement");
+  }
+  class HTMLMenuElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get compact() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "compact");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set compact(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'compact' property on 'HTMLMenuElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "compact", "");
+        } else {
+          this[impl].removeAttributeNS(null, "compact");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLMenuElement.prototype, {
+    compact: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLMenuElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLMenuElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLMenuElement
+  });
+};
+
+const Impl = require("../nodes/HTMLMenuElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLMetaElement.js b/lib/jsdom/living/generated/HTMLMetaElement.js
new file mode 100644
index 0000000..49cd967
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLMetaElement.js
@@ -0,0 +1,245 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLMetaElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLMetaElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLMetaElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLMetaElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLMetaElement before HTMLElement");
+  }
+  class HTMLMetaElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLMetaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get httpEquiv() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "http-equiv");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set httpEquiv(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'httpEquiv' property on 'HTMLMetaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "http-equiv", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get content() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "content");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set content(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'content' property on 'HTMLMetaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "content", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get scheme() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "scheme");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set scheme(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'scheme' property on 'HTMLMetaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "scheme", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLMetaElement.prototype, {
+    name: { enumerable: true },
+    httpEquiv: { enumerable: true },
+    content: { enumerable: true },
+    scheme: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLMetaElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLMetaElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLMetaElement
+  });
+};
+
+const Impl = require("../nodes/HTMLMetaElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLMeterElement.js b/lib/jsdom/living/generated/HTMLMeterElement.js
new file mode 100644
index 0000000..a42b8d1
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLMeterElement.js
@@ -0,0 +1,312 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLMeterElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLMeterElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLMeterElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLMeterElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLMeterElement before HTMLElement");
+  }
+  class HTMLMeterElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'value' property on 'HTMLMeterElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get min() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["min"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set min(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'min' property on 'HTMLMeterElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["min"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get max() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["max"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set max(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'max' property on 'HTMLMeterElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["max"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get low() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["low"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set low(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'low' property on 'HTMLMeterElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["low"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get high() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["high"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set high(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'high' property on 'HTMLMeterElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["high"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get optimum() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["optimum"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set optimum(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'optimum' property on 'HTMLMeterElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["optimum"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+  }
+  Object.defineProperties(HTMLMeterElement.prototype, {
+    value: { enumerable: true },
+    min: { enumerable: true },
+    max: { enumerable: true },
+    low: { enumerable: true },
+    high: { enumerable: true },
+    optimum: { enumerable: true },
+    labels: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLMeterElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLMeterElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLMeterElement
+  });
+};
+
+const Impl = require("../nodes/HTMLMeterElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLModElement.js b/lib/jsdom/living/generated/HTMLModElement.js
new file mode 100644
index 0000000..724c250
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLModElement.js
@@ -0,0 +1,180 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLModElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLModElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLModElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLModElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLModElement before HTMLElement");
+  }
+  class HTMLModElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get cite() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["cite"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set cite(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'cite' property on 'HTMLModElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["cite"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get dateTime() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "datetime");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set dateTime(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'dateTime' property on 'HTMLModElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "datetime", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLModElement.prototype, {
+    cite: { enumerable: true },
+    dateTime: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLModElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLModElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLModElement
+  });
+};
+
+const Impl = require("../nodes/HTMLModElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLOListElement.js b/lib/jsdom/living/generated/HTMLOListElement.js
new file mode 100644
index 0000000..20ee2d3
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLOListElement.js
@@ -0,0 +1,250 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLOListElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLOListElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLOListElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLOListElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLOListElement before HTMLElement");
+  }
+  class HTMLOListElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get reversed() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "reversed");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set reversed(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'reversed' property on 'HTMLOListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "reversed", "");
+        } else {
+          this[impl].removeAttributeNS(null, "reversed");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get start() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["start"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set start(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'start' property on 'HTMLOListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["start"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLOListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get compact() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "compact");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set compact(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'compact' property on 'HTMLOListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "compact", "");
+        } else {
+          this[impl].removeAttributeNS(null, "compact");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLOListElement.prototype, {
+    reversed: { enumerable: true },
+    start: { enumerable: true },
+    type: { enumerable: true },
+    compact: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLOListElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLOListElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLOListElement
+  });
+};
+
+const Impl = require("../nodes/HTMLOListElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLObjectElement.js b/lib/jsdom/living/generated/HTMLObjectElement.js
new file mode 100644
index 0000000..8e18436
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLObjectElement.js
@@ -0,0 +1,718 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLObjectElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLObjectElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLObjectElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLObjectElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLObjectElement before HTMLElement");
+  }
+  class HTMLObjectElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLObjectElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLObjectElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    get data() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["data"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set data(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'data' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["data"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get useMap() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "usemap");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set useMap(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'useMap' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "usemap", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "height");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'height' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "height", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get contentDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["contentDocument"]);
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["validity"]);
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get archive() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "archive");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set archive(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'archive' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "archive", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get code() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "code");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set code(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'code' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "code", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get declare() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "declare");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set declare(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'declare' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "declare", "");
+        } else {
+          this[impl].removeAttributeNS(null, "declare");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get hspace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "hspace"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set hspace(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'hspace' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "hspace", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get standby() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "standby");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set standby(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'standby' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "standby", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vspace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "vspace"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vspace(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'vspace' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "vspace", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get codeBase() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["codeBase"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set codeBase(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'codeBase' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["codeBase"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get codeType() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "codetype");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set codeType(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'codeType' property on 'HTMLObjectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "codetype", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get border() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "border");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set border(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'border' property on 'HTMLObjectElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "border", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLObjectElement.prototype, {
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    data: { enumerable: true },
+    type: { enumerable: true },
+    name: { enumerable: true },
+    useMap: { enumerable: true },
+    form: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    contentDocument: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    align: { enumerable: true },
+    archive: { enumerable: true },
+    code: { enumerable: true },
+    declare: { enumerable: true },
+    hspace: { enumerable: true },
+    standby: { enumerable: true },
+    vspace: { enumerable: true },
+    codeBase: { enumerable: true },
+    codeType: { enumerable: true },
+    border: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLObjectElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLObjectElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLObjectElement
+  });
+};
+
+const Impl = require("../nodes/HTMLObjectElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLOptGroupElement.js b/lib/jsdom/living/generated/HTMLOptGroupElement.js
new file mode 100644
index 0000000..b92720e
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLOptGroupElement.js
@@ -0,0 +1,184 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLOptGroupElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLOptGroupElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLOptGroupElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLOptGroupElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLOptGroupElement before HTMLElement");
+  }
+  class HTMLOptGroupElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLOptGroupElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get label() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "label");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set label(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'label' property on 'HTMLOptGroupElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "label", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLOptGroupElement.prototype, {
+    disabled: { enumerable: true },
+    label: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLOptGroupElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLOptGroupElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLOptGroupElement
+  });
+};
+
+const Impl = require("../nodes/HTMLOptGroupElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLOptionElement.js b/lib/jsdom/living/generated/HTMLOptionElement.js
new file mode 100644
index 0000000..9908404
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLOptionElement.js
@@ -0,0 +1,319 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLOptionElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLOptionElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLOptionElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLOptionElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLOptionElement before HTMLElement");
+  }
+  class HTMLOptionElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLOptionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get label() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["label"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set label(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'label' property on 'HTMLOptionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["label"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get defaultSelected() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "selected");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defaultSelected(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'defaultSelected' property on 'HTMLOptionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "selected", "");
+        } else {
+          this[impl].removeAttributeNS(null, "selected");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get selected() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selected"];
+    }
+
+    set selected(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'selected' property on 'HTMLOptionElement': The provided value"
+      });
+
+      this[impl]["selected"] = V;
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLOptionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get text() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["text"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set text(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'text' property on 'HTMLOptionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["text"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get index() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["index"];
+    }
+  }
+  Object.defineProperties(HTMLOptionElement.prototype, {
+    disabled: { enumerable: true },
+    form: { enumerable: true },
+    label: { enumerable: true },
+    defaultSelected: { enumerable: true },
+    selected: { enumerable: true },
+    value: { enumerable: true },
+    text: { enumerable: true },
+    index: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLOptionElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLOptionElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLOptionElement
+  });
+};
+
+const Impl = require("../nodes/HTMLOptionElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLOptionsCollection.js b/lib/jsdom/living/generated/HTMLOptionsCollection.js
new file mode 100644
index 0000000..453b178
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLOptionsCollection.js
@@ -0,0 +1,516 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isHTMLOptionElement = require("./HTMLOptionElement.js").is;
+const isHTMLOptGroupElement = require("./HTMLOptGroupElement.js").is;
+const isHTMLElement = require("./HTMLElement.js").is;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const convertHTMLOptionElement = require("./HTMLOptionElement.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLCollection = require("./HTMLCollection.js");
+
+const interfaceName = "HTMLOptionsCollection";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLOptionsCollection'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLOptionsCollection"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLOptionsCollection is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLCollection._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  {
+    let proxyHandler = proxyHandlerCache.get(globalObject);
+    if (proxyHandler === undefined) {
+      proxyHandler = new ProxyHandler(globalObject);
+      proxyHandlerCache.set(globalObject, proxyHandler);
+    }
+    obj = new Proxy(obj, proxyHandler);
+  }
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLCollection === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLOptionsCollection before HTMLCollection");
+  }
+  class HTMLOptionsCollection extends globalObject.HTMLCollection {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    add(element) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'add' on 'HTMLOptionsCollection': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (isHTMLOptionElement(curArg) || isHTMLOptGroupElement(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          throw new TypeError(
+            "Failed to execute 'add' on 'HTMLOptionsCollection': parameter 1" + " is not of any supported type."
+          );
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            if (isHTMLElement(curArg)) {
+              curArg = utils.implForWrapper(curArg);
+            } else if (typeof curArg === "number") {
+              curArg = conversions["long"](curArg, {
+                context: "Failed to execute 'add' on 'HTMLOptionsCollection': parameter 2"
+              });
+            } else {
+              curArg = conversions["long"](curArg, {
+                context: "Failed to execute 'add' on 'HTMLOptionsCollection': parameter 2"
+              });
+            }
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].add(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    remove(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'remove' on 'HTMLOptionsCollection': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["long"](curArg, {
+          context: "Failed to execute 'remove' on 'HTMLOptionsCollection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].remove(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["length"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set length(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'length' property on 'HTMLOptionsCollection': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["length"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get selectedIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectedIndex"];
+    }
+
+    set selectedIndex(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'selectedIndex' property on 'HTMLOptionsCollection': The provided value"
+      });
+
+      this[impl]["selectedIndex"] = V;
+    }
+  }
+  Object.defineProperties(HTMLOptionsCollection.prototype, {
+    add: { enumerable: true },
+    remove: { enumerable: true },
+    length: { enumerable: true },
+    selectedIndex: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLOptionsCollection", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLOptionsCollection;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLOptionsCollection
+  });
+};
+
+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[impl][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of target[impl][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;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: true,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    const namedValue = target[impl].namedItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: false,
+        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);
+    }
+    if (target === receiver) {
+      const globalObject = this._globalObject;
+
+      if (utils.isArrayIndexPropName(P)) {
+        const index = P >>> 0;
+        let indexedValue = V;
+
+        if (indexedValue === null || indexedValue === undefined) {
+          indexedValue = null;
+        } else {
+          indexedValue = convertHTMLOptionElement(indexedValue, {
+            context: "Failed to set the " + index + " property on 'HTMLOptionsCollection': The provided value"
+          });
+        }
+
+        ceReactionsPreSteps_helpers_custom_elements(globalObject);
+        try {
+          const creating = !(target[impl].item(index) !== null);
+          if (creating) {
+            target[impl][utils.indexedSetNew](index, indexedValue);
+          } else {
+            target[impl][utils.indexedSetExisting](index, indexedValue);
+          }
+        } finally {
+          ceReactionsPostSteps_helpers_custom_elements(globalObject);
+        }
+
+        return true;
+      }
+
+      typeof P === "string" && !utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: true,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  }
+
+  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;
+
+      if (indexedValue === null || indexedValue === undefined) {
+        indexedValue = null;
+      } else {
+        indexedValue = convertHTMLOptionElement(indexedValue, {
+          context: "Failed to set the " + index + " property on 'HTMLOptionsCollection': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const creating = !(target[impl].item(index) !== null);
+        if (creating) {
+          target[impl][utils.indexedSetNew](index, indexedValue);
+        } else {
+          target[impl][utils.indexedSetExisting](index, indexedValue);
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+
+      return true;
+    }
+    if (!utils.hasOwn(target, P)) {
+      const creating = !(target[impl].namedItem(P) !== null);
+      if (!creating) {
+        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[impl].item(index) !== null);
+    }
+
+    if (target[impl].namedItem(P) !== null && !(P in target)) {
+      return false;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../nodes/HTMLOptionsCollection-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLOutputElement.js b/lib/jsdom/living/generated/HTMLOutputElement.js
new file mode 100644
index 0000000..c87e3a4
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLOutputElement.js
@@ -0,0 +1,326 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLOutputElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLOutputElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLOutputElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLOutputElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLOutputElement before HTMLElement");
+  }
+  class HTMLOutputElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLOutputElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLOutputElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    get htmlFor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "htmlFor", () => {
+        return utils.tryWrapperForImpl(this[impl]["htmlFor"]);
+      });
+    }
+
+    set htmlFor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.htmlFor.value = V;
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLOutputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get defaultValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["defaultValue"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defaultValue(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'defaultValue' property on 'HTMLOutputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["defaultValue"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLOutputElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["validity"]);
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+  }
+  Object.defineProperties(HTMLOutputElement.prototype, {
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    htmlFor: { enumerable: true },
+    form: { enumerable: true },
+    name: { enumerable: true },
+    type: { enumerable: true },
+    defaultValue: { enumerable: true },
+    value: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    labels: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLOutputElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLOutputElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLOutputElement
+  });
+};
+
+const Impl = require("../nodes/HTMLOutputElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLParagraphElement.js b/lib/jsdom/living/generated/HTMLParagraphElement.js
new file mode 100644
index 0000000..d72c39b
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLParagraphElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLParagraphElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLParagraphElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLParagraphElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLParagraphElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLParagraphElement before HTMLElement");
+  }
+  class HTMLParagraphElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLParagraphElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLParagraphElement.prototype, {
+    align: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLParagraphElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLParagraphElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLParagraphElement
+  });
+};
+
+const Impl = require("../nodes/HTMLParagraphElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLParamElement.js b/lib/jsdom/living/generated/HTMLParamElement.js
new file mode 100644
index 0000000..548361b
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLParamElement.js
@@ -0,0 +1,245 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLParamElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLParamElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLParamElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLParamElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLParamElement before HTMLElement");
+  }
+  class HTMLParamElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLParamElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "value");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLParamElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "value", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLParamElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get valueType() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "valuetype");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set valueType(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'valueType' property on 'HTMLParamElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "valuetype", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLParamElement.prototype, {
+    name: { enumerable: true },
+    value: { enumerable: true },
+    type: { enumerable: true },
+    valueType: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLParamElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLParamElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLParamElement
+  });
+};
+
+const Impl = require("../nodes/HTMLParamElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLPictureElement.js b/lib/jsdom/living/generated/HTMLPictureElement.js
new file mode 100644
index 0000000..a4ad35a
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLPictureElement.js
@@ -0,0 +1,115 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLPictureElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLPictureElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLPictureElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLPictureElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLPictureElement before HTMLElement");
+  }
+  class HTMLPictureElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+  }
+  Object.defineProperties(HTMLPictureElement.prototype, {
+    [Symbol.toStringTag]: { value: "HTMLPictureElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLPictureElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLPictureElement
+  });
+};
+
+const Impl = require("../nodes/HTMLPictureElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLPreElement.js b/lib/jsdom/living/generated/HTMLPreElement.js
new file mode 100644
index 0000000..5cf342f
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLPreElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLPreElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLPreElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLPreElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLPreElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLPreElement before HTMLElement");
+  }
+  class HTMLPreElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "width"));
+        return isNaN(value) || value < -2147483648 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'width' property on 'HTMLPreElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", String(V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLPreElement.prototype, {
+    width: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLPreElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLPreElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLPreElement
+  });
+};
+
+const Impl = require("../nodes/HTMLPreElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLProgressElement.js b/lib/jsdom/living/generated/HTMLProgressElement.js
new file mode 100644
index 0000000..6c37a5c
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLProgressElement.js
@@ -0,0 +1,197 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLProgressElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLProgressElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLProgressElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLProgressElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLProgressElement before HTMLElement");
+  }
+  class HTMLProgressElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'value' property on 'HTMLProgressElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get max() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["max"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set max(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["double"](V, {
+        context: "Failed to set the 'max' property on 'HTMLProgressElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["max"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get position() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["position"];
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+  }
+  Object.defineProperties(HTMLProgressElement.prototype, {
+    value: { enumerable: true },
+    max: { enumerable: true },
+    position: { enumerable: true },
+    labels: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLProgressElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLProgressElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLProgressElement
+  });
+};
+
+const Impl = require("../nodes/HTMLProgressElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLQuoteElement.js b/lib/jsdom/living/generated/HTMLQuoteElement.js
new file mode 100644
index 0000000..7f32985
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLQuoteElement.js
@@ -0,0 +1,148 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLQuoteElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLQuoteElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLQuoteElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLQuoteElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLQuoteElement before HTMLElement");
+  }
+  class HTMLQuoteElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get cite() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["cite"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set cite(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'cite' property on 'HTMLQuoteElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["cite"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLQuoteElement.prototype, {
+    cite: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLQuoteElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLQuoteElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLQuoteElement
+  });
+};
+
+const Impl = require("../nodes/HTMLQuoteElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLScriptElement.js b/lib/jsdom/living/generated/HTMLScriptElement.js
new file mode 100644
index 0000000..0e4f0b6
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLScriptElement.js
@@ -0,0 +1,378 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLScriptElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLScriptElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLScriptElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLScriptElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLScriptElement before HTMLElement");
+  }
+  class HTMLScriptElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get defer() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "defer");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defer(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'defer' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "defer", "");
+        } else {
+          this[impl].removeAttributeNS(null, "defer");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get crossOrigin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "crossorigin");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set crossOrigin(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'crossOrigin' property on 'HTMLScriptElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "crossorigin", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get text() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["text"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set text(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'text' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["text"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get charset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charset");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set charset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'charset' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charset", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get event() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "event");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set event(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'event' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "event", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get htmlFor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "for");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set htmlFor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'htmlFor' property on 'HTMLScriptElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "for", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLScriptElement.prototype, {
+    src: { enumerable: true },
+    type: { enumerable: true },
+    defer: { enumerable: true },
+    crossOrigin: { enumerable: true },
+    text: { enumerable: true },
+    charset: { enumerable: true },
+    event: { enumerable: true },
+    htmlFor: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLScriptElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLScriptElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLScriptElement
+  });
+};
+
+const Impl = require("../nodes/HTMLScriptElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLSelectElement.js b/lib/jsdom/living/generated/HTMLSelectElement.js
new file mode 100644
index 0000000..94d0ce4
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLSelectElement.js
@@ -0,0 +1,876 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const isHTMLOptionElement = require("./HTMLOptionElement.js").is;
+const isHTMLOptGroupElement = require("./HTMLOptGroupElement.js").is;
+const isHTMLElement = require("./HTMLElement.js").is;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const convertHTMLOptionElement = require("./HTMLOptionElement.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLSelectElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLSelectElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLSelectElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLSelectElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  {
+    let proxyHandler = proxyHandlerCache.get(globalObject);
+    if (proxyHandler === undefined) {
+      proxyHandler = new ProxyHandler(globalObject);
+      proxyHandlerCache.set(globalObject, proxyHandler);
+    }
+    obj = new Proxy(obj, proxyHandler);
+  }
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLSelectElement before HTMLElement");
+  }
+  class HTMLSelectElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'HTMLSelectElement': 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 'HTMLSelectElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    namedItem(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'namedItem' on 'HTMLSelectElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'namedItem' on 'HTMLSelectElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].namedItem(...args));
+    }
+
+    add(element) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'add' on 'HTMLSelectElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (isHTMLOptionElement(curArg) || isHTMLOptGroupElement(curArg)) {
+          curArg = utils.implForWrapper(curArg);
+        } else {
+          throw new TypeError(
+            "Failed to execute 'add' on 'HTMLSelectElement': parameter 1" + " is not of any supported type."
+          );
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            if (isHTMLElement(curArg)) {
+              curArg = utils.implForWrapper(curArg);
+            } else if (typeof curArg === "number") {
+              curArg = conversions["long"](curArg, {
+                context: "Failed to execute 'add' on 'HTMLSelectElement': parameter 2"
+              });
+            } else {
+              curArg = conversions["long"](curArg, {
+                context: "Failed to execute 'add' on 'HTMLSelectElement': parameter 2"
+              });
+            }
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].add(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    remove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      switch (arguments.length) {
+        case 0:
+          break;
+        default: {
+          let curArg = arguments[0];
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'remove' on 'HTMLSelectElement': parameter 1"
+          });
+          args.push(curArg);
+        }
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].remove(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLSelectElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLSelectElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    get autofocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "autofocus");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autofocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'autofocus' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "autofocus", "");
+        } else {
+          this[impl].removeAttributeNS(null, "autofocus");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get multiple() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "multiple");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set multiple(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'multiple' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "multiple", "");
+        } else {
+          this[impl].removeAttributeNS(null, "multiple");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get required() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "required");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set required(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'required' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "required", "");
+        } else {
+          this[impl].removeAttributeNS(null, "required");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get size() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "size"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set size(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'size' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "size", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get options() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "options", () => {
+        return utils.tryWrapperForImpl(this[impl]["options"]);
+      });
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["length"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set length(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'length' property on 'HTMLSelectElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["length"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get selectedOptions() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "selectedOptions", () => {
+        return utils.tryWrapperForImpl(this[impl]["selectedOptions"]);
+      });
+    }
+
+    get selectedIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectedIndex"];
+    }
+
+    set selectedIndex(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'selectedIndex' property on 'HTMLSelectElement': The provided value"
+      });
+
+      this[impl]["selectedIndex"] = V;
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["value"];
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLSelectElement': The provided value"
+      });
+
+      this[impl]["value"] = V;
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["validity"]);
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+  }
+  Object.defineProperties(HTMLSelectElement.prototype, {
+    item: { enumerable: true },
+    namedItem: { enumerable: true },
+    add: { enumerable: true },
+    remove: { enumerable: true },
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    autofocus: { enumerable: true },
+    disabled: { enumerable: true },
+    form: { enumerable: true },
+    multiple: { enumerable: true },
+    name: { enumerable: true },
+    required: { enumerable: true },
+    size: { enumerable: true },
+    type: { enumerable: true },
+    options: { enumerable: true },
+    length: { enumerable: true },
+    selectedOptions: { enumerable: true },
+    selectedIndex: { enumerable: true },
+    value: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    labels: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLSelectElement", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLSelectElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLSelectElement
+  });
+};
+
+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[impl][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[impl].item(index);
+      if (indexedValue !== null) {
+        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);
+    }
+    if (target === receiver) {
+      const globalObject = this._globalObject;
+
+      if (utils.isArrayIndexPropName(P)) {
+        const index = P >>> 0;
+        let indexedValue = V;
+
+        if (indexedValue === null || indexedValue === undefined) {
+          indexedValue = null;
+        } else {
+          indexedValue = convertHTMLOptionElement(indexedValue, {
+            context: "Failed to set the " + index + " property on 'HTMLSelectElement': The provided value"
+          });
+        }
+
+        ceReactionsPreSteps_helpers_custom_elements(globalObject);
+        try {
+          const creating = !(target[impl].item(index) !== null);
+          if (creating) {
+            target[impl][utils.indexedSetNew](index, indexedValue);
+          } else {
+            target[impl][utils.indexedSetExisting](index, indexedValue);
+          }
+        } finally {
+          ceReactionsPostSteps_helpers_custom_elements(globalObject);
+        }
+
+        return true;
+      }
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: true,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  }
+
+  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;
+
+      if (indexedValue === null || indexedValue === undefined) {
+        indexedValue = null;
+      } else {
+        indexedValue = convertHTMLOptionElement(indexedValue, {
+          context: "Failed to set the " + index + " property on 'HTMLSelectElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const creating = !(target[impl].item(index) !== null);
+        if (creating) {
+          target[impl][utils.indexedSetNew](index, indexedValue);
+        } else {
+          target[impl][utils.indexedSetExisting](index, indexedValue);
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+
+      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[impl].item(index) !== null);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../nodes/HTMLSelectElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLSlotElement.js b/lib/jsdom/living/generated/HTMLSlotElement.js
new file mode 100644
index 0000000..3e660d9
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLSlotElement.js
@@ -0,0 +1,182 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const convertAssignedNodesOptions = require("./AssignedNodesOptions.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLSlotElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLSlotElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLSlotElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLSlotElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLSlotElement before HTMLElement");
+  }
+  class HTMLSlotElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    assignedNodes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAssignedNodesOptions(curArg, {
+          context: "Failed to execute 'assignedNodes' on 'HTMLSlotElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].assignedNodes(...args));
+    }
+
+    assignedElements() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAssignedNodesOptions(curArg, {
+          context: "Failed to execute 'assignedElements' on 'HTMLSlotElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].assignedElements(...args));
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLSlotElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLSlotElement.prototype, {
+    assignedNodes: { enumerable: true },
+    assignedElements: { enumerable: true },
+    name: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLSlotElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLSlotElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLSlotElement
+  });
+};
+
+const Impl = require("../nodes/HTMLSlotElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLSourceElement.js b/lib/jsdom/living/generated/HTMLSourceElement.js
new file mode 100644
index 0000000..4c3e9c4
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLSourceElement.js
@@ -0,0 +1,275 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLSourceElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLSourceElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLSourceElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLSourceElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLSourceElement before HTMLElement");
+  }
+  class HTMLSourceElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLSourceElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLSourceElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get srcset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["srcset"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set srcset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'srcset' property on 'HTMLSourceElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["srcset"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get sizes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "sizes");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set sizes(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'sizes' property on 'HTMLSourceElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "sizes", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get media() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "media");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set media(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'media' property on 'HTMLSourceElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "media", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLSourceElement.prototype, {
+    src: { enumerable: true },
+    type: { enumerable: true },
+    srcset: { enumerable: true },
+    sizes: { enumerable: true },
+    media: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLSourceElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLSourceElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLSourceElement
+  });
+};
+
+const Impl = require("../nodes/HTMLSourceElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLSpanElement.js b/lib/jsdom/living/generated/HTMLSpanElement.js
new file mode 100644
index 0000000..b8b41ca
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLSpanElement.js
@@ -0,0 +1,115 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLSpanElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLSpanElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLSpanElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLSpanElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLSpanElement before HTMLElement");
+  }
+  class HTMLSpanElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+  }
+  Object.defineProperties(HTMLSpanElement.prototype, {
+    [Symbol.toStringTag]: { value: "HTMLSpanElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLSpanElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLSpanElement
+  });
+};
+
+const Impl = require("../nodes/HTMLSpanElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLStyleElement.js b/lib/jsdom/living/generated/HTMLStyleElement.js
new file mode 100644
index 0000000..2b16b8d
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLStyleElement.js
@@ -0,0 +1,190 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLStyleElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLStyleElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLStyleElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLStyleElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLStyleElement before HTMLElement");
+  }
+  class HTMLStyleElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get media() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "media");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set media(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'media' property on 'HTMLStyleElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "media", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLStyleElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get sheet() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["sheet"]);
+    }
+  }
+  Object.defineProperties(HTMLStyleElement.prototype, {
+    media: { enumerable: true },
+    type: { enumerable: true },
+    sheet: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLStyleElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLStyleElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLStyleElement
+  });
+};
+
+const Impl = require("../nodes/HTMLStyleElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTableCaptionElement.js b/lib/jsdom/living/generated/HTMLTableCaptionElement.js
new file mode 100644
index 0000000..709a851
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTableCaptionElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTableCaptionElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTableCaptionElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTableCaptionElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTableCaptionElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTableCaptionElement before HTMLElement");
+  }
+  class HTMLTableCaptionElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLTableCaptionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTableCaptionElement.prototype, {
+    align: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTableCaptionElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTableCaptionElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTableCaptionElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTableCaptionElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTableCellElement.js b/lib/jsdom/living/generated/HTMLTableCellElement.js
new file mode 100644
index 0000000..e53af02
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTableCellElement.js
@@ -0,0 +1,575 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTableCellElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTableCellElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTableCellElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTableCellElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTableCellElement before HTMLElement");
+  }
+  class HTMLTableCellElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get colSpan() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["colSpan"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set colSpan(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'colSpan' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["colSpan"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rowSpan() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["rowSpan"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rowSpan(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'rowSpan' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["rowSpan"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get headers() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "headers");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set headers(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'headers' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "headers", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get cellIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["cellIndex"];
+    }
+
+    get scope() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["scope"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set scope(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'scope' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["scope"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get abbr() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "abbr");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set abbr(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'abbr' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "abbr", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get axis() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "axis");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set axis(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'axis' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "axis", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "height");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'height' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "height", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get ch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "char");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set ch(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'ch' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "char", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get chOff() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charoff");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set chOff(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'chOff' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charoff", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get noWrap() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "nowrap");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set noWrap(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'noWrap' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "nowrap", "");
+        } else {
+          this[impl].removeAttributeNS(null, "nowrap");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vAlign() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "valign");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vAlign(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'vAlign' property on 'HTMLTableCellElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "valign", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get bgColor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "bgcolor");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set bgColor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'bgColor' property on 'HTMLTableCellElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "bgcolor", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTableCellElement.prototype, {
+    colSpan: { enumerable: true },
+    rowSpan: { enumerable: true },
+    headers: { enumerable: true },
+    cellIndex: { enumerable: true },
+    scope: { enumerable: true },
+    abbr: { enumerable: true },
+    align: { enumerable: true },
+    axis: { enumerable: true },
+    height: { enumerable: true },
+    width: { enumerable: true },
+    ch: { enumerable: true },
+    chOff: { enumerable: true },
+    noWrap: { enumerable: true },
+    vAlign: { enumerable: true },
+    bgColor: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTableCellElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTableCellElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTableCellElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTableCellElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTableColElement.js b/lib/jsdom/living/generated/HTMLTableColElement.js
new file mode 100644
index 0000000..c262cf5
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTableColElement.js
@@ -0,0 +1,309 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTableColElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTableColElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTableColElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTableColElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTableColElement before HTMLElement");
+  }
+  class HTMLTableColElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get span() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "span"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set span(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'span' property on 'HTMLTableColElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "span", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLTableColElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get ch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "char");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set ch(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'ch' property on 'HTMLTableColElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "char", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get chOff() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charoff");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set chOff(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'chOff' property on 'HTMLTableColElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charoff", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vAlign() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "valign");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vAlign(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'vAlign' property on 'HTMLTableColElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "valign", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLTableColElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTableColElement.prototype, {
+    span: { enumerable: true },
+    align: { enumerable: true },
+    ch: { enumerable: true },
+    chOff: { enumerable: true },
+    vAlign: { enumerable: true },
+    width: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTableColElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTableColElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTableColElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTableColElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTableElement.js b/lib/jsdom/living/generated/HTMLTableElement.js
new file mode 100644
index 0000000..199ae45
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTableElement.js
@@ -0,0 +1,664 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const convertHTMLTableCaptionElement = require("./HTMLTableCaptionElement.js").convert;
+const convertHTMLTableSectionElement = require("./HTMLTableSectionElement.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTableElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTableElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTableElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTableElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTableElement before HTMLElement");
+  }
+  class HTMLTableElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    createCaption() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createCaption());
+    }
+
+    deleteCaption() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteCaption();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    createTHead() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createTHead());
+    }
+
+    deleteTHead() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteTHead();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    createTFoot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createTFoot());
+    }
+
+    deleteTFoot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteTFoot();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    createTBody() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createTBody());
+    }
+
+    insertRow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'insertRow' on 'HTMLTableElement': parameter 1"
+          });
+        } else {
+          curArg = -1;
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].insertRow(...args));
+    }
+
+    deleteRow(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'deleteRow' on 'HTMLTableElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["long"](curArg, {
+          context: "Failed to execute 'deleteRow' on 'HTMLTableElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteRow(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get caption() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl]["caption"]);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set caption(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = convertHTMLTableCaptionElement(V, {
+          context: "Failed to set the 'caption' property on 'HTMLTableElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["caption"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get tHead() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl]["tHead"]);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set tHead(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = convertHTMLTableSectionElement(V, {
+          context: "Failed to set the 'tHead' property on 'HTMLTableElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["tHead"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get tFoot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl]["tFoot"]);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set tFoot(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = convertHTMLTableSectionElement(V, {
+          context: "Failed to set the 'tFoot' property on 'HTMLTableElement': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["tFoot"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get tBodies() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "tBodies", () => {
+        return utils.tryWrapperForImpl(this[impl]["tBodies"]);
+      });
+    }
+
+    get rows() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "rows", () => {
+        return utils.tryWrapperForImpl(this[impl]["rows"]);
+      });
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLTableElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get border() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "border");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set border(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'border' property on 'HTMLTableElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "border", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get frame() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "frame");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set frame(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'frame' property on 'HTMLTableElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "frame", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rules() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "rules");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rules(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'rules' property on 'HTMLTableElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "rules", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get summary() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "summary");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set summary(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'summary' property on 'HTMLTableElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "summary", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "width");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'width' property on 'HTMLTableElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get bgColor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "bgcolor");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set bgColor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'bgColor' property on 'HTMLTableElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "bgcolor", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get cellPadding() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "cellpadding");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set cellPadding(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'cellPadding' property on 'HTMLTableElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "cellpadding", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get cellSpacing() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "cellspacing");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set cellSpacing(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'cellSpacing' property on 'HTMLTableElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "cellspacing", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTableElement.prototype, {
+    createCaption: { enumerable: true },
+    deleteCaption: { enumerable: true },
+    createTHead: { enumerable: true },
+    deleteTHead: { enumerable: true },
+    createTFoot: { enumerable: true },
+    deleteTFoot: { enumerable: true },
+    createTBody: { enumerable: true },
+    insertRow: { enumerable: true },
+    deleteRow: { enumerable: true },
+    caption: { enumerable: true },
+    tHead: { enumerable: true },
+    tFoot: { enumerable: true },
+    tBodies: { enumerable: true },
+    rows: { enumerable: true },
+    align: { enumerable: true },
+    border: { enumerable: true },
+    frame: { enumerable: true },
+    rules: { enumerable: true },
+    summary: { enumerable: true },
+    width: { enumerable: true },
+    bgColor: { enumerable: true },
+    cellPadding: { enumerable: true },
+    cellSpacing: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTableElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTableElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTableElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTableElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTableRowElement.js b/lib/jsdom/living/generated/HTMLTableRowElement.js
new file mode 100644
index 0000000..5a25b50
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTableRowElement.js
@@ -0,0 +1,356 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTableRowElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTableRowElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTableRowElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTableRowElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTableRowElement before HTMLElement");
+  }
+  class HTMLTableRowElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    insertCell() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'insertCell' on 'HTMLTableRowElement': parameter 1"
+          });
+        } else {
+          curArg = -1;
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].insertCell(...args));
+    }
+
+    deleteCell(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'deleteCell' on 'HTMLTableRowElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["long"](curArg, {
+          context: "Failed to execute 'deleteCell' on 'HTMLTableRowElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteCell(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rowIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["rowIndex"];
+    }
+
+    get sectionRowIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["sectionRowIndex"];
+    }
+
+    get cells() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "cells", () => {
+        return utils.tryWrapperForImpl(this[impl]["cells"]);
+      });
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLTableRowElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get ch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "char");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set ch(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'ch' property on 'HTMLTableRowElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "char", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get chOff() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charoff");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set chOff(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'chOff' property on 'HTMLTableRowElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charoff", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vAlign() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "valign");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vAlign(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'vAlign' property on 'HTMLTableRowElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "valign", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get bgColor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "bgcolor");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set bgColor(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'bgColor' property on 'HTMLTableRowElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "bgcolor", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTableRowElement.prototype, {
+    insertCell: { enumerable: true },
+    deleteCell: { enumerable: true },
+    rowIndex: { enumerable: true },
+    sectionRowIndex: { enumerable: true },
+    cells: { enumerable: true },
+    align: { enumerable: true },
+    ch: { enumerable: true },
+    chOff: { enumerable: true },
+    vAlign: { enumerable: true },
+    bgColor: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTableRowElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTableRowElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTableRowElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTableRowElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTableSectionElement.js b/lib/jsdom/living/generated/HTMLTableSectionElement.js
new file mode 100644
index 0000000..83a4b69
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTableSectionElement.js
@@ -0,0 +1,305 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTableSectionElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTableSectionElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTableSectionElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTableSectionElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTableSectionElement before HTMLElement");
+  }
+  class HTMLTableSectionElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    insertRow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'insertRow' on 'HTMLTableSectionElement': parameter 1"
+          });
+        } else {
+          curArg = -1;
+        }
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].insertRow(...args));
+    }
+
+    deleteRow(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'deleteRow' on 'HTMLTableSectionElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["long"](curArg, {
+          context: "Failed to execute 'deleteRow' on 'HTMLTableSectionElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteRow(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rows() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "rows", () => {
+        return utils.tryWrapperForImpl(this[impl]["rows"]);
+      });
+    }
+
+    get align() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "align");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set align(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'align' property on 'HTMLTableSectionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "align", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get ch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "char");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set ch(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'ch' property on 'HTMLTableSectionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "char", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get chOff() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "charoff");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set chOff(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'chOff' property on 'HTMLTableSectionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "charoff", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get vAlign() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "valign");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set vAlign(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'vAlign' property on 'HTMLTableSectionElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "valign", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTableSectionElement.prototype, {
+    insertRow: { enumerable: true },
+    deleteRow: { enumerable: true },
+    rows: { enumerable: true },
+    align: { enumerable: true },
+    ch: { enumerable: true },
+    chOff: { enumerable: true },
+    vAlign: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTableSectionElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTableSectionElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTableSectionElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTableSectionElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTemplateElement.js b/lib/jsdom/living/generated/HTMLTemplateElement.js
new file mode 100644
index 0000000..1b0d0f4
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTemplateElement.js
@@ -0,0 +1,124 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTemplateElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTemplateElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTemplateElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTemplateElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTemplateElement before HTMLElement");
+  }
+  class HTMLTemplateElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get content() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["content"]);
+    }
+  }
+  Object.defineProperties(HTMLTemplateElement.prototype, {
+    content: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTemplateElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTemplateElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTemplateElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTemplateElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTextAreaElement.js b/lib/jsdom/living/generated/HTMLTextAreaElement.js
new file mode 100644
index 0000000..d00cc60
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTextAreaElement.js
@@ -0,0 +1,947 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const convertSelectionMode = require("./SelectionMode.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTextAreaElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTextAreaElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTextAreaElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTextAreaElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTextAreaElement before HTMLElement");
+  }
+  class HTMLTextAreaElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    checkValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].checkValidity();
+    }
+
+    reportValidity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].reportValidity();
+    }
+
+    setCustomValidity(error) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setCustomValidity' on 'HTMLTextAreaElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setCustomValidity' on 'HTMLTextAreaElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setCustomValidity(...args);
+    }
+
+    select() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].select();
+    }
+
+    setRangeText(replacement) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      switch (arguments.length) {
+        case 1:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 1"
+            });
+            args.push(curArg);
+          }
+          break;
+        case 2:
+          throw new TypeError(
+            "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': only " +
+              arguments.length +
+              " arguments present."
+          );
+          break;
+        case 3:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 3"
+            });
+            args.push(curArg);
+          }
+          break;
+        default:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["unsigned long"](curArg, {
+              context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 3"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[3];
+            if (curArg !== undefined) {
+              curArg = convertSelectionMode(curArg, {
+                context: "Failed to execute 'setRangeText' on 'HTMLTextAreaElement': parameter 4"
+              });
+            } else {
+              curArg = "preserve";
+            }
+            args.push(curArg);
+          }
+      }
+      return this[impl].setRangeText(...args);
+    }
+
+    setSelectionRange(start, end) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'setSelectionRange' on 'HTMLTextAreaElement': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setSelectionRange' on 'HTMLTextAreaElement': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setSelectionRange' on 'HTMLTextAreaElement': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'setSelectionRange' on 'HTMLTextAreaElement': parameter 3"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].setSelectionRange(...args);
+    }
+
+    get autocomplete() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "autocomplete");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autocomplete(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'autocomplete' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "autocomplete", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get autofocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "autofocus");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set autofocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'autofocus' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "autofocus", "");
+        } else {
+          this[impl].removeAttributeNS(null, "autofocus");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get cols() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["cols"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set cols(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'cols' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["cols"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get dirName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "dirname");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set dirName(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'dirName' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "dirname", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get disabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "disabled");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set disabled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'disabled' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "disabled", "");
+        } else {
+          this[impl].removeAttributeNS(null, "disabled");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get form() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["form"]);
+    }
+
+    get inputMode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "inputmode");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set inputMode(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'inputMode' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "inputmode", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get maxLength() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "maxlength"));
+        return isNaN(value) || value < -2147483648 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set maxLength(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'maxLength' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "maxlength", String(V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get minLength() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "minlength"));
+        return isNaN(value) || value < -2147483648 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set minLength(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'minLength' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "minlength", String(V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "name");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set name(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'name' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "name", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get placeholder() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "placeholder");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set placeholder(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'placeholder' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "placeholder", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get readOnly() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "readonly");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set readOnly(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'readOnly' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "readonly", "");
+        } else {
+          this[impl].removeAttributeNS(null, "readonly");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get required() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "required");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set required(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'required' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "required", "");
+        } else {
+          this[impl].removeAttributeNS(null, "required");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get rows() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["rows"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set rows(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'rows' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["rows"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get wrap() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "wrap");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set wrap(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'wrap' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "wrap", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get defaultValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["defaultValue"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set defaultValue(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'defaultValue' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["defaultValue"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["value"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'HTMLTextAreaElement': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["value"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get textLength() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["textLength"];
+    }
+
+    get willValidate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["willValidate"];
+    }
+
+    get validity() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["validity"]);
+    }
+
+    get validationMessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["validationMessage"];
+    }
+
+    get labels() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["labels"]);
+    }
+
+    get selectionStart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectionStart"];
+    }
+
+    set selectionStart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'selectionStart' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      this[impl]["selectionStart"] = V;
+    }
+
+    get selectionEnd() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectionEnd"];
+    }
+
+    set selectionEnd(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'selectionEnd' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      this[impl]["selectionEnd"] = V;
+    }
+
+    get selectionDirection() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["selectionDirection"];
+    }
+
+    set selectionDirection(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'selectionDirection' property on 'HTMLTextAreaElement': The provided value"
+      });
+
+      this[impl]["selectionDirection"] = V;
+    }
+  }
+  Object.defineProperties(HTMLTextAreaElement.prototype, {
+    checkValidity: { enumerable: true },
+    reportValidity: { enumerable: true },
+    setCustomValidity: { enumerable: true },
+    select: { enumerable: true },
+    setRangeText: { enumerable: true },
+    setSelectionRange: { enumerable: true },
+    autocomplete: { enumerable: true },
+    autofocus: { enumerable: true },
+    cols: { enumerable: true },
+    dirName: { enumerable: true },
+    disabled: { enumerable: true },
+    form: { enumerable: true },
+    inputMode: { enumerable: true },
+    maxLength: { enumerable: true },
+    minLength: { enumerable: true },
+    name: { enumerable: true },
+    placeholder: { enumerable: true },
+    readOnly: { enumerable: true },
+    required: { enumerable: true },
+    rows: { enumerable: true },
+    wrap: { enumerable: true },
+    type: { enumerable: true },
+    defaultValue: { enumerable: true },
+    value: { enumerable: true },
+    textLength: { enumerable: true },
+    willValidate: { enumerable: true },
+    validity: { enumerable: true },
+    validationMessage: { enumerable: true },
+    labels: { enumerable: true },
+    selectionStart: { enumerable: true },
+    selectionEnd: { enumerable: true },
+    selectionDirection: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTextAreaElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTextAreaElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTextAreaElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTextAreaElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTimeElement.js b/lib/jsdom/living/generated/HTMLTimeElement.js
new file mode 100644
index 0000000..127d552
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTimeElement.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTimeElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTimeElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTimeElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTimeElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTimeElement before HTMLElement");
+  }
+  class HTMLTimeElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get dateTime() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "datetime");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set dateTime(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'dateTime' property on 'HTMLTimeElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "datetime", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTimeElement.prototype, {
+    dateTime: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTimeElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTimeElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTimeElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTimeElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTitleElement.js b/lib/jsdom/living/generated/HTMLTitleElement.js
new file mode 100644
index 0000000..d65d0ef
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTitleElement.js
@@ -0,0 +1,148 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTitleElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTitleElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTitleElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTitleElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTitleElement before HTMLElement");
+  }
+  class HTMLTitleElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get text() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["text"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set text(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'text' property on 'HTMLTitleElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["text"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLTitleElement.prototype, {
+    text: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTitleElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTitleElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTitleElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTitleElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLTrackElement.js b/lib/jsdom/living/generated/HTMLTrackElement.js
new file mode 100644
index 0000000..345d505
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLTrackElement.js
@@ -0,0 +1,298 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLTrackElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLTrackElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLTrackElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLTrackElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLTrackElement before HTMLElement");
+  }
+  class HTMLTrackElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get kind() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "kind");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set kind(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'kind' property on 'HTMLTrackElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "kind", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get src() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["src"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set src(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'src' property on 'HTMLTrackElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["src"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get srclang() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "srclang");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set srclang(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'srclang' property on 'HTMLTrackElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "srclang", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get label() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "label");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set label(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'label' property on 'HTMLTrackElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "label", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get default() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "default");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set default(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'default' property on 'HTMLTrackElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "default", "");
+        } else {
+          this[impl].removeAttributeNS(null, "default");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get readyState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["readyState"];
+    }
+  }
+  Object.defineProperties(HTMLTrackElement.prototype, {
+    kind: { enumerable: true },
+    src: { enumerable: true },
+    srclang: { enumerable: true },
+    label: { enumerable: true },
+    default: { enumerable: true },
+    readyState: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLTrackElement", configurable: true },
+    NONE: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    LOADED: { value: 2, enumerable: true },
+    ERROR: { value: 3, enumerable: true }
+  });
+  Object.defineProperties(HTMLTrackElement, {
+    NONE: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    LOADED: { value: 2, enumerable: true },
+    ERROR: { value: 3, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLTrackElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLTrackElement
+  });
+};
+
+const Impl = require("../nodes/HTMLTrackElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLUListElement.js b/lib/jsdom/living/generated/HTMLUListElement.js
new file mode 100644
index 0000000..30bb9fa
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLUListElement.js
@@ -0,0 +1,184 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLUListElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLUListElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLUListElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLUListElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLUListElement before HTMLElement");
+  }
+  class HTMLUListElement extends globalObject.HTMLElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get compact() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "compact");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set compact(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'compact' property on 'HTMLUListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "compact", "");
+        } else {
+          this[impl].removeAttributeNS(null, "compact");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = this[impl].getAttributeNS(null, "type");
+        return value === null ? "" : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set type(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'type' property on 'HTMLUListElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "type", V);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLUListElement.prototype, {
+    compact: { enumerable: true },
+    type: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLUListElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLUListElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLUListElement
+  });
+};
+
+const Impl = require("../nodes/HTMLUListElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLUnknownElement.js b/lib/jsdom/living/generated/HTMLUnknownElement.js
new file mode 100644
index 0000000..7e2de36
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLUnknownElement.js
@@ -0,0 +1,114 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLElement = require("./HTMLElement.js");
+
+const interfaceName = "HTMLUnknownElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLUnknownElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLUnknownElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLUnknownElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLUnknownElement before HTMLElement");
+  }
+  class HTMLUnknownElement extends globalObject.HTMLElement {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(HTMLUnknownElement.prototype, {
+    [Symbol.toStringTag]: { value: "HTMLUnknownElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLUnknownElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLUnknownElement
+  });
+};
+
+const Impl = require("../nodes/HTMLUnknownElement-impl.js");
diff --git a/lib/jsdom/living/generated/HTMLVideoElement.js b/lib/jsdom/living/generated/HTMLVideoElement.js
new file mode 100644
index 0000000..e8a26b5
--- /dev/null
+++ b/lib/jsdom/living/generated/HTMLVideoElement.js
@@ -0,0 +1,265 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const HTMLConstructor_helpers_html_constructor = require("../helpers/html-constructor.js").HTMLConstructor;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const HTMLMediaElement = require("./HTMLMediaElement.js");
+
+const interfaceName = "HTMLVideoElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HTMLVideoElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HTMLVideoElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HTMLVideoElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  HTMLMediaElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.HTMLMediaElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate HTMLVideoElement before HTMLMediaElement");
+  }
+  class HTMLVideoElement extends globalObject.HTMLMediaElement {
+    constructor() {
+      return HTMLConstructor_helpers_html_constructor(globalObject, interfaceName, new.target);
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "width"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set width(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'width' property on 'HTMLVideoElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "width", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        const value = parseInt(this[impl].getAttributeNS(null, "height"));
+        return isNaN(value) || value < 0 || value > 2147483647 ? 0 : value;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set height(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'height' property on 'HTMLVideoElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl].setAttributeNS(null, "height", String(V > 2147483647 ? 0 : V));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get videoWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["videoWidth"];
+    }
+
+    get videoHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["videoHeight"];
+    }
+
+    get poster() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["poster"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set poster(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["USVString"](V, {
+        context: "Failed to set the 'poster' property on 'HTMLVideoElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["poster"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get playsInline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].hasAttributeNS(null, "playsinline");
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set playsInline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'playsInline' property on 'HTMLVideoElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        if (V) {
+          this[impl].setAttributeNS(null, "playsinline", "");
+        } else {
+          this[impl].removeAttributeNS(null, "playsinline");
+        }
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(HTMLVideoElement.prototype, {
+    width: { enumerable: true },
+    height: { enumerable: true },
+    videoWidth: { enumerable: true },
+    videoHeight: { enumerable: true },
+    poster: { enumerable: true },
+    playsInline: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HTMLVideoElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HTMLVideoElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HTMLVideoElement
+  });
+};
+
+const Impl = require("../nodes/HTMLVideoElement-impl.js");
diff --git a/lib/jsdom/living/generated/HashChangeEvent.js b/lib/jsdom/living/generated/HashChangeEvent.js
new file mode 100644
index 0000000..c91d8f7
--- /dev/null
+++ b/lib/jsdom/living/generated/HashChangeEvent.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertHashChangeEventInit = require("./HashChangeEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "HashChangeEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'HashChangeEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["HashChangeEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor HashChangeEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate HashChangeEvent before Event");
+  }
+  class HashChangeEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'HashChangeEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'HashChangeEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertHashChangeEventInit(curArg, { context: "Failed to construct 'HashChangeEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get oldURL() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["oldURL"];
+    }
+
+    get newURL() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["newURL"];
+    }
+  }
+  Object.defineProperties(HashChangeEvent.prototype, {
+    oldURL: { enumerable: true },
+    newURL: { enumerable: true },
+    [Symbol.toStringTag]: { value: "HashChangeEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = HashChangeEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: HashChangeEvent
+  });
+};
+
+const Impl = require("../events/HashChangeEvent-impl.js");
diff --git a/lib/jsdom/living/generated/HashChangeEventInit.js b/lib/jsdom/living/generated/HashChangeEventInit.js
new file mode 100644
index 0000000..4c29aae
--- /dev/null
+++ b/lib/jsdom/living/generated/HashChangeEventInit.js
@@ -0,0 +1,44 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "newURL";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["USVString"](value, { context: context + " has member newURL that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "oldURL";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["USVString"](value, { context: context + " has member oldURL that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Headers.js b/lib/jsdom/living/generated/Headers.js
new file mode 100644
index 0000000..2965686
--- /dev/null
+++ b/lib/jsdom/living/generated/Headers.js
@@ -0,0 +1,386 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Headers";
+
+const IteratorPrototype = Object.create(utils.IteratorPrototype, {
+  next: {
+    value: function next() {
+      const internal = this[utils.iterInternalSymbol];
+      const { target, kind, index } = internal;
+      const values = Array.from(target[impl]);
+      const len = values.length;
+      if (index >= len) {
+        return { value: undefined, done: true };
+      }
+
+      const pair = values[index];
+      internal.index = index + 1;
+      const [key, value] = pair.map(utils.tryWrapperForImpl);
+
+      let result;
+      switch (kind) {
+        case "key":
+          result = key;
+          break;
+        case "value":
+          result = value;
+          break;
+        case "key+value":
+          result = [key, value];
+          break;
+      }
+      return { value: result, done: false };
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  },
+  [Symbol.toStringTag]: {
+    value: "Headers Iterator",
+    configurable: true
+  }
+});
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Headers'.`);
+};
+
+exports.createDefaultIterator = function createDefaultIterator(target, kind) {
+  const iterator = Object.create(IteratorPrototype);
+  Object.defineProperty(iterator, utils.iterInternalSymbol, {
+    value: { target, kind, index: 0 },
+    configurable: true
+  });
+  return iterator;
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Headers"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Headers is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Headers {
+    constructor() {
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          if (utils.isObject(curArg)) {
+            if (curArg[Symbol.iterator] !== undefined) {
+              if (!utils.isObject(curArg)) {
+                throw new TypeError(
+                  "Failed to construct 'Headers': parameter 1" + " sequence" + " is not an iterable object."
+                );
+              } else {
+                const V = [];
+                const tmp = curArg;
+                for (let nextItem of tmp) {
+                  if (!utils.isObject(nextItem)) {
+                    throw new TypeError(
+                      "Failed to construct 'Headers': parameter 1" +
+                        " sequence" +
+                        "'s element" +
+                        " is not an iterable object."
+                    );
+                  } else {
+                    const V = [];
+                    const tmp = nextItem;
+                    for (let nextItem of tmp) {
+                      nextItem = conversions["ByteString"](nextItem, {
+                        context:
+                          "Failed to construct 'Headers': parameter 1" + " sequence" + "'s element" + "'s element"
+                      });
+
+                      V.push(nextItem);
+                    }
+                    nextItem = V;
+                  }
+
+                  V.push(nextItem);
+                }
+                curArg = V;
+              }
+            } else {
+              if (!utils.isObject(curArg)) {
+                throw new TypeError("Failed to construct 'Headers': parameter 1" + " record" + " is not an object.");
+              } else {
+                const result = Object.create(null);
+                for (const key of Reflect.ownKeys(curArg)) {
+                  const desc = Object.getOwnPropertyDescriptor(curArg, key);
+                  if (desc && desc.enumerable) {
+                    let typedKey = key;
+
+                    typedKey = conversions["ByteString"](typedKey, {
+                      context: "Failed to construct 'Headers': parameter 1" + " record" + "'s key"
+                    });
+
+                    let typedValue = curArg[key];
+
+                    typedValue = conversions["ByteString"](typedValue, {
+                      context: "Failed to construct 'Headers': parameter 1" + " record" + "'s value"
+                    });
+
+                    result[typedKey] = typedValue;
+                  }
+                }
+                curArg = result;
+              }
+            }
+          } else {
+            throw new TypeError("Failed to construct 'Headers': parameter 1" + " is not of any supported type.");
+          }
+        }
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    append(name, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'append' on 'Headers': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'append' on 'Headers': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'append' on 'Headers': parameter 2" });
+        args.push(curArg);
+      }
+      return this[impl].append(...args);
+    }
+
+    delete(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'delete' on 'Headers': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'delete' on 'Headers': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].delete(...args);
+    }
+
+    get(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'get' on 'Headers': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'get' on 'Headers': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].get(...args);
+    }
+
+    has(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'has' on 'Headers': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'has' on 'Headers': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].has(...args);
+    }
+
+    set(name, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'set' on 'Headers': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'set' on 'Headers': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["ByteString"](curArg, { context: "Failed to execute 'set' on 'Headers': parameter 2" });
+        args.push(curArg);
+      }
+      return this[impl].set(...args);
+    }
+
+    keys() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      return exports.createDefaultIterator(this, "key");
+    }
+
+    values() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      return exports.createDefaultIterator(this, "value");
+    }
+
+    entries() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      return exports.createDefaultIterator(this, "key+value");
+    }
+
+    forEach(callback) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      if (arguments.length < 1) {
+        throw new TypeError("Failed to execute 'forEach' on 'iterable': 1 argument required, " + "but only 0 present.");
+      }
+      if (typeof callback !== "function") {
+        throw new TypeError(
+          "Failed to execute 'forEach' on 'iterable': The callback provided " + "as parameter 1 is not a function."
+        );
+      }
+      const thisArg = arguments[1];
+      let pairs = Array.from(this[impl]);
+      let i = 0;
+      while (i < pairs.length) {
+        const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
+        callback.call(thisArg, value, key, this);
+        pairs = Array.from(this[impl]);
+        i++;
+      }
+    }
+  }
+  Object.defineProperties(Headers.prototype, {
+    append: { enumerable: true },
+    delete: { enumerable: true },
+    get: { enumerable: true },
+    has: { enumerable: true },
+    set: { enumerable: true },
+    keys: { enumerable: true },
+    values: { enumerable: true },
+    entries: { enumerable: true },
+    forEach: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Headers", configurable: true },
+    [Symbol.iterator]: { value: Headers.prototype.entries, configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Headers;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Headers
+  });
+};
+
+const Impl = require("../fetch/Headers-impl.js");
diff --git a/lib/jsdom/living/generated/History.js b/lib/jsdom/living/generated/History.js
new file mode 100644
index 0000000..5b321d5
--- /dev/null
+++ b/lib/jsdom/living/generated/History.js
@@ -0,0 +1,248 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "History";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'History'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["History"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor History is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class History {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    go() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, { context: "Failed to execute 'go' on 'History': parameter 1" });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return this[impl].go(...args);
+    }
+
+    back() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].back();
+    }
+
+    forward() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].forward();
+    }
+
+    pushState(data, title) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'pushState' on 'History': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["any"](curArg, { context: "Failed to execute 'pushState' on 'History': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'pushState' on 'History': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'pushState' on 'History': parameter 3"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return this[impl].pushState(...args);
+    }
+
+    replaceState(data, title) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'replaceState' on 'History': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["any"](curArg, { context: "Failed to execute 'replaceState' on 'History': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'replaceState' on 'History': parameter 2"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'replaceState' on 'History': parameter 3"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return this[impl].replaceState(...args);
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+
+    get state() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["state"];
+    }
+  }
+  Object.defineProperties(History.prototype, {
+    go: { enumerable: true },
+    back: { enumerable: true },
+    forward: { enumerable: true },
+    pushState: { enumerable: true },
+    replaceState: { enumerable: true },
+    length: { enumerable: true },
+    state: { enumerable: true },
+    [Symbol.toStringTag]: { value: "History", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = History;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: History
+  });
+};
+
+const Impl = require("../window/History-impl.js");
diff --git a/lib/jsdom/living/generated/InputEvent.js b/lib/jsdom/living/generated/InputEvent.js
new file mode 100644
index 0000000..29e2a06
--- /dev/null
+++ b/lib/jsdom/living/generated/InputEvent.js
@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertInputEventInit = require("./InputEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const UIEvent = require("./UIEvent.js");
+
+const interfaceName = "InputEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'InputEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["InputEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor InputEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  UIEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.UIEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate InputEvent before UIEvent");
+  }
+  class InputEvent extends globalObject.UIEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'InputEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'InputEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertInputEventInit(curArg, { context: "Failed to construct 'InputEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get data() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["data"];
+    }
+
+    get isComposing() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["isComposing"];
+    }
+  }
+  Object.defineProperties(InputEvent.prototype, {
+    data: { enumerable: true },
+    isComposing: { enumerable: true },
+    [Symbol.toStringTag]: { value: "InputEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = InputEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: InputEvent
+  });
+};
+
+const Impl = require("../events/InputEvent-impl.js");
diff --git a/lib/jsdom/living/generated/InputEventInit.js b/lib/jsdom/living/generated/InputEventInit.js
new file mode 100644
index 0000000..14c7fc9
--- /dev/null
+++ b/lib/jsdom/living/generated/InputEventInit.js
@@ -0,0 +1,47 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const UIEventInit = require("./UIEventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  UIEventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "data";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = conversions["DOMString"](value, { context: context + " has member data that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "isComposing";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member isComposing that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/KeyboardEvent.js b/lib/jsdom/living/generated/KeyboardEvent.js
new file mode 100644
index 0000000..8e2576b
--- /dev/null
+++ b/lib/jsdom/living/generated/KeyboardEvent.js
@@ -0,0 +1,389 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertKeyboardEventInit = require("./KeyboardEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const UIEvent = require("./UIEvent.js");
+
+const interfaceName = "KeyboardEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'KeyboardEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["KeyboardEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor KeyboardEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  UIEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.UIEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate KeyboardEvent before UIEvent");
+  }
+  class KeyboardEvent extends globalObject.UIEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'KeyboardEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'KeyboardEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertKeyboardEventInit(curArg, { context: "Failed to construct 'KeyboardEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    getModifierState(keyArg) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getModifierState' on 'KeyboardEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getModifierState' on 'KeyboardEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].getModifierState(...args);
+    }
+
+    initKeyboardEvent(typeArg) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[4];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 5"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[5];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned long"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 6"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[6];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 7"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[7];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 8"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[8];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 9"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[9];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': parameter 10"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return this[impl].initKeyboardEvent(...args);
+    }
+
+    get key() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["key"];
+    }
+
+    get code() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["code"];
+    }
+
+    get location() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["location"];
+    }
+
+    get ctrlKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["ctrlKey"];
+    }
+
+    get shiftKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["shiftKey"];
+    }
+
+    get altKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["altKey"];
+    }
+
+    get metaKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["metaKey"];
+    }
+
+    get repeat() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["repeat"];
+    }
+
+    get isComposing() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["isComposing"];
+    }
+
+    get charCode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["charCode"];
+    }
+
+    get keyCode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["keyCode"];
+    }
+  }
+  Object.defineProperties(KeyboardEvent.prototype, {
+    getModifierState: { enumerable: true },
+    initKeyboardEvent: { enumerable: true },
+    key: { enumerable: true },
+    code: { enumerable: true },
+    location: { enumerable: true },
+    ctrlKey: { enumerable: true },
+    shiftKey: { enumerable: true },
+    altKey: { enumerable: true },
+    metaKey: { enumerable: true },
+    repeat: { enumerable: true },
+    isComposing: { enumerable: true },
+    charCode: { enumerable: true },
+    keyCode: { enumerable: true },
+    [Symbol.toStringTag]: { value: "KeyboardEvent", configurable: true },
+    DOM_KEY_LOCATION_STANDARD: { value: 0x00, enumerable: true },
+    DOM_KEY_LOCATION_LEFT: { value: 0x01, enumerable: true },
+    DOM_KEY_LOCATION_RIGHT: { value: 0x02, enumerable: true },
+    DOM_KEY_LOCATION_NUMPAD: { value: 0x03, enumerable: true }
+  });
+  Object.defineProperties(KeyboardEvent, {
+    DOM_KEY_LOCATION_STANDARD: { value: 0x00, enumerable: true },
+    DOM_KEY_LOCATION_LEFT: { value: 0x01, enumerable: true },
+    DOM_KEY_LOCATION_RIGHT: { value: 0x02, enumerable: true },
+    DOM_KEY_LOCATION_NUMPAD: { value: 0x03, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = KeyboardEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: KeyboardEvent
+  });
+};
+
+const Impl = require("../events/KeyboardEvent-impl.js");
diff --git a/lib/jsdom/living/generated/KeyboardEventInit.js b/lib/jsdom/living/generated/KeyboardEventInit.js
new file mode 100644
index 0000000..4a49851
--- /dev/null
+++ b/lib/jsdom/living/generated/KeyboardEventInit.js
@@ -0,0 +1,104 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventModifierInit = require("./EventModifierInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventModifierInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "charCode";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member charCode that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "code";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member code that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "isComposing";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member isComposing that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "key";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member key that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "keyCode";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member keyCode that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "location";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member location that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "repeat";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member repeat that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Location.js b/lib/jsdom/living/generated/Location.js
new file mode 100644
index 0000000..193450b
--- /dev/null
+++ b/lib/jsdom/living/generated/Location.js
@@ -0,0 +1,332 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Location";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Location'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Location"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Location is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Object.defineProperties(
+    obj,
+    Object.getOwnPropertyDescriptors({
+      assign(url) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        if (arguments.length < 1) {
+          throw new TypeError(
+            "Failed to execute 'assign' on 'Location': 1 argument required, but only " + arguments.length + " present."
+          );
+        }
+        const args = [];
+        {
+          let curArg = arguments[0];
+          curArg = conversions["USVString"](curArg, {
+            context: "Failed to execute 'assign' on 'Location': parameter 1"
+          });
+          args.push(curArg);
+        }
+        return this[impl].assign(...args);
+      },
+      replace(url) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        if (arguments.length < 1) {
+          throw new TypeError(
+            "Failed to execute 'replace' on 'Location': 1 argument required, but only " + arguments.length + " present."
+          );
+        }
+        const args = [];
+        {
+          let curArg = arguments[0];
+          curArg = conversions["USVString"](curArg, {
+            context: "Failed to execute 'replace' on 'Location': parameter 1"
+          });
+          args.push(curArg);
+        }
+        return this[impl].replace(...args);
+      },
+      reload() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return this[impl].reload();
+      },
+      get href() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["href"];
+      },
+      set href(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'href' property on 'Location': The provided value"
+        });
+
+        obj[impl]["href"] = V;
+      },
+      toString() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+        return obj[impl]["href"];
+      },
+      get origin() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["origin"];
+      },
+      get protocol() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["protocol"];
+      },
+      set protocol(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'protocol' property on 'Location': The provided value"
+        });
+
+        obj[impl]["protocol"] = V;
+      },
+      get host() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["host"];
+      },
+      set host(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'host' property on 'Location': The provided value"
+        });
+
+        obj[impl]["host"] = V;
+      },
+      get hostname() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["hostname"];
+      },
+      set hostname(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'hostname' property on 'Location': The provided value"
+        });
+
+        obj[impl]["hostname"] = V;
+      },
+      get port() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["port"];
+      },
+      set port(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'port' property on 'Location': The provided value"
+        });
+
+        obj[impl]["port"] = V;
+      },
+      get pathname() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["pathname"];
+      },
+      set pathname(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'pathname' property on 'Location': The provided value"
+        });
+
+        obj[impl]["pathname"] = V;
+      },
+      get search() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["search"];
+      },
+      set search(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'search' property on 'Location': The provided value"
+        });
+
+        obj[impl]["search"] = V;
+      },
+      get hash() {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        return obj[impl]["hash"];
+      },
+      set hash(V) {
+        if (!this || !exports.is(this)) {
+          throw new TypeError("Illegal invocation");
+        }
+
+        V = conversions["USVString"](V, {
+          context: "Failed to set the 'hash' property on 'Location': The provided value"
+        });
+
+        obj[impl]["hash"] = V;
+      }
+    })
+  );
+
+  Object.defineProperties(obj, {
+    assign: { configurable: false, writable: false },
+    replace: { configurable: false, writable: false },
+    reload: { configurable: false, writable: false },
+    href: { configurable: false },
+    toString: { configurable: false, writable: false },
+    origin: { configurable: false },
+    protocol: { configurable: false },
+    host: { configurable: false },
+    hostname: { configurable: false },
+    port: { configurable: false },
+    pathname: { configurable: false },
+    search: { configurable: false },
+    hash: { configurable: false }
+  });
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Location {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(Location.prototype, { [Symbol.toStringTag]: { value: "Location", configurable: true } });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Location;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Location
+  });
+};
+
+const Impl = require("../window/Location-impl.js");
diff --git a/lib/jsdom/living/generated/MessageEvent.js b/lib/jsdom/living/generated/MessageEvent.js
new file mode 100644
index 0000000..67882ae
--- /dev/null
+++ b/lib/jsdom/living/generated/MessageEvent.js
@@ -0,0 +1,290 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertMessageEventInit = require("./MessageEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "MessageEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'MessageEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["MessageEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor MessageEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate MessageEvent before Event");
+  }
+  class MessageEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'MessageEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'MessageEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertMessageEventInit(curArg, { context: "Failed to construct 'MessageEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    initMessageEvent(type) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initMessageEvent' on 'MessageEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          curArg = conversions["any"](curArg, {
+            context: "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 4"
+          });
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[4];
+        if (curArg !== undefined) {
+          curArg = conversions["USVString"](curArg, {
+            context: "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 5"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[5];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 6"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[6];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[7];
+        if (curArg !== undefined) {
+          if (!utils.isObject(curArg)) {
+            throw new TypeError(
+              "Failed to execute 'initMessageEvent' on 'MessageEvent': parameter 8" + " is not an iterable object."
+            );
+          } else {
+            const V = [];
+            const tmp = curArg;
+            for (let nextItem of tmp) {
+              nextItem = utils.tryImplForWrapper(nextItem);
+
+              V.push(nextItem);
+            }
+            curArg = V;
+          }
+        } else {
+          curArg = [];
+        }
+        args.push(curArg);
+      }
+      return this[impl].initMessageEvent(...args);
+    }
+
+    get data() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["data"];
+    }
+
+    get origin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["origin"];
+    }
+
+    get lastEventId() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["lastEventId"];
+    }
+
+    get source() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["source"]);
+    }
+
+    get ports() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ports"]);
+    }
+  }
+  Object.defineProperties(MessageEvent.prototype, {
+    initMessageEvent: { enumerable: true },
+    data: { enumerable: true },
+    origin: { enumerable: true },
+    lastEventId: { enumerable: true },
+    source: { enumerable: true },
+    ports: { enumerable: true },
+    [Symbol.toStringTag]: { value: "MessageEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = MessageEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: MessageEvent
+  });
+};
+
+const Impl = require("../events/MessageEvent-impl.js");
diff --git a/lib/jsdom/living/generated/MessageEventInit.js b/lib/jsdom/living/generated/MessageEventInit.js
new file mode 100644
index 0000000..c302199
--- /dev/null
+++ b/lib/jsdom/living/generated/MessageEventInit.js
@@ -0,0 +1,94 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "data";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["any"](value, { context: context + " has member data that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "lastEventId";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, { context: context + " has member lastEventId that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "origin";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["USVString"](value, { context: context + " has member origin that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "ports";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new TypeError(context + " has member ports that" + " is not an iterable object.");
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = utils.tryImplForWrapper(nextItem);
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    } else {
+      ret[key] = [];
+    }
+  }
+
+  {
+    const key = "source";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = utils.tryImplForWrapper(value);
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/MimeType.js b/lib/jsdom/living/generated/MimeType.js
new file mode 100644
index 0000000..8a20540
--- /dev/null
+++ b/lib/jsdom/living/generated/MimeType.js
@@ -0,0 +1,144 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "MimeType";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'MimeType'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["MimeType"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor MimeType is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class MimeType {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get description() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["description"];
+    }
+
+    get suffixes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["suffixes"];
+    }
+
+    get enabledPlugin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["enabledPlugin"]);
+    }
+  }
+  Object.defineProperties(MimeType.prototype, {
+    type: { enumerable: true },
+    description: { enumerable: true },
+    suffixes: { enumerable: true },
+    enabledPlugin: { enumerable: true },
+    [Symbol.toStringTag]: { value: "MimeType", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = MimeType;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: MimeType
+  });
+};
+
+const Impl = require("../navigator/MimeType-impl.js");
diff --git a/lib/jsdom/living/generated/MimeTypeArray.js b/lib/jsdom/living/generated/MimeTypeArray.js
new file mode 100644
index 0000000..0f97474
--- /dev/null
+++ b/lib/jsdom/living/generated/MimeTypeArray.js
@@ -0,0 +1,352 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "MimeTypeArray";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'MimeTypeArray'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["MimeTypeArray"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor MimeTypeArray is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class MimeTypeArray {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'MimeTypeArray': 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 'MimeTypeArray': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    namedItem(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'namedItem' on 'MimeTypeArray': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'namedItem' on 'MimeTypeArray': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].namedItem(...args));
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+  }
+  Object.defineProperties(MimeTypeArray.prototype, {
+    item: { enumerable: true },
+    namedItem: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "MimeTypeArray", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = MimeTypeArray;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: MimeTypeArray
+  });
+};
+
+const proxyHandler = {
+  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[impl][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of target[impl][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;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    const namedValue = target[impl].namedItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: false,
+        enumerable: false,
+        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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+
+      typeof P === "string" && !utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+    if (!utils.hasOwn(target, P)) {
+      const creating = !(target[impl].namedItem(P) !== null);
+      if (!creating) {
+        return false;
+      }
+    }
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    if (target[impl].namedItem(P) !== null && !(P in target)) {
+      return false;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../navigator/MimeTypeArray-impl.js");
diff --git a/lib/jsdom/living/generated/MouseEvent.js b/lib/jsdom/living/generated/MouseEvent.js
new file mode 100644
index 0000000..889dfc4
--- /dev/null
+++ b/lib/jsdom/living/generated/MouseEvent.js
@@ -0,0 +1,439 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertMouseEventInit = require("./MouseEventInit.js").convert;
+const convertEventTarget = require("./EventTarget.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const UIEvent = require("./UIEvent.js");
+
+const interfaceName = "MouseEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'MouseEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["MouseEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor MouseEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  UIEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.UIEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate MouseEvent before UIEvent");
+  }
+  class MouseEvent extends globalObject.UIEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'MouseEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'MouseEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertMouseEventInit(curArg, { context: "Failed to construct 'MouseEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    getModifierState(keyArg) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getModifierState' on 'MouseEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getModifierState' on 'MouseEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].getModifierState(...args);
+    }
+
+    initMouseEvent(typeArg) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initMouseEvent' on 'MouseEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[4];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 5"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[5];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 6"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[6];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 7"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[7];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 8"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[8];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 9"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[9];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 10"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[10];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 11"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[11];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 12"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[12];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 13"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[13];
+        if (curArg !== undefined) {
+          curArg = conversions["short"](curArg, {
+            context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 14"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[14];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = convertEventTarget(curArg, {
+              context: "Failed to execute 'initMouseEvent' on 'MouseEvent': parameter 15"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return this[impl].initMouseEvent(...args);
+    }
+
+    get screenX() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["screenX"];
+    }
+
+    get screenY() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["screenY"];
+    }
+
+    get clientX() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["clientX"];
+    }
+
+    get clientY() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["clientY"];
+    }
+
+    get ctrlKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["ctrlKey"];
+    }
+
+    get shiftKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["shiftKey"];
+    }
+
+    get altKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["altKey"];
+    }
+
+    get metaKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["metaKey"];
+    }
+
+    get button() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["button"];
+    }
+
+    get buttons() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["buttons"];
+    }
+
+    get relatedTarget() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["relatedTarget"]);
+    }
+  }
+  Object.defineProperties(MouseEvent.prototype, {
+    getModifierState: { enumerable: true },
+    initMouseEvent: { enumerable: true },
+    screenX: { enumerable: true },
+    screenY: { enumerable: true },
+    clientX: { enumerable: true },
+    clientY: { enumerable: true },
+    ctrlKey: { enumerable: true },
+    shiftKey: { enumerable: true },
+    altKey: { enumerable: true },
+    metaKey: { enumerable: true },
+    button: { enumerable: true },
+    buttons: { enumerable: true },
+    relatedTarget: { enumerable: true },
+    [Symbol.toStringTag]: { value: "MouseEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = MouseEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: MouseEvent
+  });
+};
+
+const Impl = require("../events/MouseEvent-impl.js");
diff --git a/lib/jsdom/living/generated/MouseEventInit.js b/lib/jsdom/living/generated/MouseEventInit.js
new file mode 100644
index 0000000..40d063c
--- /dev/null
+++ b/lib/jsdom/living/generated/MouseEventInit.js
@@ -0,0 +1,108 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertEventTarget = require("./EventTarget.js").convert;
+const EventModifierInit = require("./EventModifierInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventModifierInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "button";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["short"](value, { context: context + " has member button that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "buttons";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned short"](value, { context: context + " has member buttons that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "clientX";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member clientX that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "clientY";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member clientY that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "relatedTarget";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = convertEventTarget(value, { context: context + " has member relatedTarget that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "screenX";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member screenX that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "screenY";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member screenY that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/MutationObserver.js b/lib/jsdom/living/generated/MutationObserver.js
new file mode 100644
index 0000000..d14e62a
--- /dev/null
+++ b/lib/jsdom/living/generated/MutationObserver.js
@@ -0,0 +1,168 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertNode = require("./Node.js").convert;
+const convertMutationObserverInit = require("./MutationObserverInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "MutationObserver";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'MutationObserver'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["MutationObserver"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor MutationObserver is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class MutationObserver {
+    constructor(callback) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'MutationObserver': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = utils.tryImplForWrapper(curArg);
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    observe(target) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'observe' on 'MutationObserver': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'observe' on 'MutationObserver': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertMutationObserverInit(curArg, {
+          context: "Failed to execute 'observe' on 'MutationObserver': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].observe(...args);
+    }
+
+    disconnect() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].disconnect();
+    }
+
+    takeRecords() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].takeRecords());
+    }
+  }
+  Object.defineProperties(MutationObserver.prototype, {
+    observe: { enumerable: true },
+    disconnect: { enumerable: true },
+    takeRecords: { enumerable: true },
+    [Symbol.toStringTag]: { value: "MutationObserver", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = MutationObserver;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: MutationObserver
+  });
+};
+
+const Impl = require("../mutation-observer/MutationObserver-impl.js");
diff --git a/lib/jsdom/living/generated/MutationObserverInit.js b/lib/jsdom/living/generated/MutationObserverInit.js
new file mode 100644
index 0000000..5822e59
--- /dev/null
+++ b/lib/jsdom/living/generated/MutationObserverInit.js
@@ -0,0 +1,103 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "attributeFilter";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new TypeError(context + " has member attributeFilter that" + " is not an iterable object.");
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = conversions["DOMString"](nextItem, {
+            context: context + " has member attributeFilter that" + "'s element"
+          });
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "attributeOldValue";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member attributeOldValue that" });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "attributes";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member attributes that" });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "characterData";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member characterData that" });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "characterDataOldValue";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member characterDataOldValue that" });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "childList";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member childList that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "subtree";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member subtree that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/MutationRecord.js b/lib/jsdom/living/generated/MutationRecord.js
new file mode 100644
index 0000000..70ea897
--- /dev/null
+++ b/lib/jsdom/living/generated/MutationRecord.js
@@ -0,0 +1,195 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "MutationRecord";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'MutationRecord'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["MutationRecord"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor MutationRecord is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class MutationRecord {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["type"];
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "target", () => {
+        return utils.tryWrapperForImpl(this[impl]["target"]);
+      });
+    }
+
+    get addedNodes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "addedNodes", () => {
+        return utils.tryWrapperForImpl(this[impl]["addedNodes"]);
+      });
+    }
+
+    get removedNodes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "removedNodes", () => {
+        return utils.tryWrapperForImpl(this[impl]["removedNodes"]);
+      });
+    }
+
+    get previousSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["previousSibling"]);
+    }
+
+    get nextSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["nextSibling"]);
+    }
+
+    get attributeName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["attributeName"];
+    }
+
+    get attributeNamespace() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["attributeNamespace"];
+    }
+
+    get oldValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["oldValue"];
+    }
+  }
+  Object.defineProperties(MutationRecord.prototype, {
+    type: { enumerable: true },
+    target: { enumerable: true },
+    addedNodes: { enumerable: true },
+    removedNodes: { enumerable: true },
+    previousSibling: { enumerable: true },
+    nextSibling: { enumerable: true },
+    attributeName: { enumerable: true },
+    attributeNamespace: { enumerable: true },
+    oldValue: { enumerable: true },
+    [Symbol.toStringTag]: { value: "MutationRecord", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = MutationRecord;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: MutationRecord
+  });
+};
+
+const Impl = require("../mutation-observer/MutationRecord-impl.js");
diff --git a/lib/jsdom/living/generated/NamedNodeMap.js b/lib/jsdom/living/generated/NamedNodeMap.js
new file mode 100644
index 0000000..f0a3765
--- /dev/null
+++ b/lib/jsdom/living/generated/NamedNodeMap.js
@@ -0,0 +1,513 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertAttr = require("./Attr.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "NamedNodeMap";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'NamedNodeMap'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["NamedNodeMap"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor NamedNodeMap is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class NamedNodeMap {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'NamedNodeMap': 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 'NamedNodeMap': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    getNamedItem(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getNamedItem' on 'NamedNodeMap': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getNamedItem' on 'NamedNodeMap': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getNamedItem(...args));
+    }
+
+    getNamedItemNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'getNamedItemNS' on 'NamedNodeMap': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'getNamedItemNS' on 'NamedNodeMap': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getNamedItemNS' on 'NamedNodeMap': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getNamedItemNS(...args));
+    }
+
+    setNamedItem(attr) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setNamedItem' on 'NamedNodeMap': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAttr(curArg, { context: "Failed to execute 'setNamedItem' on 'NamedNodeMap': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].setNamedItem(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    setNamedItemNS(attr) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setNamedItemNS' on 'NamedNodeMap': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertAttr(curArg, { context: "Failed to execute 'setNamedItemNS' on 'NamedNodeMap': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].setNamedItemNS(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    removeNamedItem(qualifiedName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'removeNamedItem' on 'NamedNodeMap': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'removeNamedItem' on 'NamedNodeMap': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].removeNamedItem(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    removeNamedItemNS(namespace, localName) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'removeNamedItemNS' on 'NamedNodeMap': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'removeNamedItemNS' on 'NamedNodeMap': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'removeNamedItemNS' on 'NamedNodeMap': parameter 2"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].removeNamedItemNS(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+  }
+  Object.defineProperties(NamedNodeMap.prototype, {
+    item: { enumerable: true },
+    getNamedItem: { enumerable: true },
+    getNamedItemNS: { enumerable: true },
+    setNamedItem: { enumerable: true },
+    setNamedItemNS: { enumerable: true },
+    removeNamedItem: { enumerable: true },
+    removeNamedItemNS: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "NamedNodeMap", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = NamedNodeMap;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: NamedNodeMap
+  });
+};
+
+const proxyHandler = {
+  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[impl][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of target[impl][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;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    const namedValue = target[impl].getNamedItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: false,
+        enumerable: false,
+        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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+
+      typeof P === "string" && !utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+    if (!utils.hasOwn(target, P)) {
+      const creating = !(target[impl].getNamedItem(P) !== null);
+      if (!creating) {
+        return false;
+      }
+    }
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    if (target[impl].getNamedItem(P) !== null && !(P in target)) {
+      return false;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../attributes/NamedNodeMap-impl.js");
diff --git a/lib/jsdom/living/generated/Navigator.js b/lib/jsdom/living/generated/Navigator.js
new file mode 100644
index 0000000..d41f252
--- /dev/null
+++ b/lib/jsdom/living/generated/Navigator.js
@@ -0,0 +1,265 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Navigator";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Navigator'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Navigator"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Navigator is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Navigator {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    javaEnabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].javaEnabled();
+    }
+
+    get appCodeName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["appCodeName"];
+    }
+
+    get appName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["appName"];
+    }
+
+    get appVersion() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["appVersion"];
+    }
+
+    get platform() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["platform"];
+    }
+
+    get product() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["product"];
+    }
+
+    get productSub() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["productSub"];
+    }
+
+    get userAgent() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["userAgent"];
+    }
+
+    get vendor() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["vendor"];
+    }
+
+    get vendorSub() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["vendorSub"];
+    }
+
+    get language() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["language"];
+    }
+
+    get languages() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["languages"]);
+    }
+
+    get onLine() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["onLine"];
+    }
+
+    get cookieEnabled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["cookieEnabled"];
+    }
+
+    get plugins() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "plugins", () => {
+        return utils.tryWrapperForImpl(this[impl]["plugins"]);
+      });
+    }
+
+    get mimeTypes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "mimeTypes", () => {
+        return utils.tryWrapperForImpl(this[impl]["mimeTypes"]);
+      });
+    }
+
+    get hardwareConcurrency() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["hardwareConcurrency"];
+    }
+  }
+  Object.defineProperties(Navigator.prototype, {
+    javaEnabled: { enumerable: true },
+    appCodeName: { enumerable: true },
+    appName: { enumerable: true },
+    appVersion: { enumerable: true },
+    platform: { enumerable: true },
+    product: { enumerable: true },
+    productSub: { enumerable: true },
+    userAgent: { enumerable: true },
+    vendor: { enumerable: true },
+    vendorSub: { enumerable: true },
+    language: { enumerable: true },
+    languages: { enumerable: true },
+    onLine: { enumerable: true },
+    cookieEnabled: { enumerable: true },
+    plugins: { enumerable: true },
+    mimeTypes: { enumerable: true },
+    hardwareConcurrency: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Navigator", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Navigator;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Navigator
+  });
+};
+
+const Impl = require("../navigator/Navigator-impl.js");
diff --git a/lib/jsdom/living/generated/Node.js b/lib/jsdom/living/generated/Node.js
new file mode 100644
index 0000000..706fe0a
--- /dev/null
+++ b/lib/jsdom/living/generated/Node.js
@@ -0,0 +1,693 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertGetRootNodeOptions = require("./GetRootNodeOptions.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "Node";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Node'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Node"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Node is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  EventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.EventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate Node before EventTarget");
+  }
+  class Node extends globalObject.EventTarget {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    getRootNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertGetRootNodeOptions(curArg, {
+          context: "Failed to execute 'getRootNode' on 'Node': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getRootNode(...args));
+    }
+
+    hasChildNodes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].hasChildNodes();
+    }
+
+    normalize() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].normalize();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    cloneNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, { context: "Failed to execute 'cloneNode' on 'Node': parameter 1" });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].cloneNode(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    isEqualNode(otherNode) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'isEqualNode' on 'Node': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = module.exports.convert(curArg, {
+            context: "Failed to execute 'isEqualNode' on 'Node': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].isEqualNode(...args);
+    }
+
+    isSameNode(otherNode) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'isSameNode' on 'Node': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = module.exports.convert(curArg, { context: "Failed to execute 'isSameNode' on 'Node': parameter 1" });
+        }
+        args.push(curArg);
+      }
+      return this[impl].isSameNode(...args);
+    }
+
+    compareDocumentPosition(other) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'compareDocumentPosition' on 'Node': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = module.exports.convert(curArg, {
+          context: "Failed to execute 'compareDocumentPosition' on 'Node': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].compareDocumentPosition(...args);
+    }
+
+    contains(other) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'contains' on 'Node': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = module.exports.convert(curArg, { context: "Failed to execute 'contains' on 'Node': parameter 1" });
+        }
+        args.push(curArg);
+      }
+      return this[impl].contains(...args);
+    }
+
+    lookupPrefix(namespace) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'lookupPrefix' on 'Node': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'lookupPrefix' on 'Node': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].lookupPrefix(...args);
+    }
+
+    lookupNamespaceURI(prefix) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'lookupNamespaceURI' on 'Node': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'lookupNamespaceURI' on 'Node': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].lookupNamespaceURI(...args);
+    }
+
+    isDefaultNamespace(namespace) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'isDefaultNamespace' on 'Node': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to execute 'isDefaultNamespace' on 'Node': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].isDefaultNamespace(...args);
+    }
+
+    insertBefore(node, child) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'insertBefore' on 'Node': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = module.exports.convert(curArg, { context: "Failed to execute 'insertBefore' on 'Node': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = module.exports.convert(curArg, {
+            context: "Failed to execute 'insertBefore' on 'Node': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].insertBefore(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    appendChild(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'appendChild' on 'Node': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = module.exports.convert(curArg, { context: "Failed to execute 'appendChild' on 'Node': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].appendChild(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    replaceChild(node, child) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'replaceChild' on 'Node': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = module.exports.convert(curArg, { context: "Failed to execute 'replaceChild' on 'Node': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = module.exports.convert(curArg, { context: "Failed to execute 'replaceChild' on 'Node': parameter 2" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].replaceChild(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    removeChild(child) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'removeChild' on 'Node': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = module.exports.convert(curArg, { context: "Failed to execute 'removeChild' on 'Node': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].removeChild(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get nodeType() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["nodeType"];
+    }
+
+    get nodeName() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["nodeName"];
+    }
+
+    get baseURI() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["baseURI"];
+    }
+
+    get isConnected() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["isConnected"];
+    }
+
+    get ownerDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ownerDocument"]);
+    }
+
+    get parentNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["parentNode"]);
+    }
+
+    get parentElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["parentElement"]);
+    }
+
+    get childNodes() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "childNodes", () => {
+        return utils.tryWrapperForImpl(this[impl]["childNodes"]);
+      });
+    }
+
+    get firstChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["firstChild"]);
+    }
+
+    get lastChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["lastChild"]);
+    }
+
+    get previousSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["previousSibling"]);
+    }
+
+    get nextSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["nextSibling"]);
+    }
+
+    get nodeValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["nodeValue"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set nodeValue(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'nodeValue' property on 'Node': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["nodeValue"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get textContent() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["textContent"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set textContent(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (V === null || V === undefined) {
+        V = null;
+      } else {
+        V = conversions["DOMString"](V, {
+          context: "Failed to set the 'textContent' property on 'Node': The provided value"
+        });
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["textContent"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(Node.prototype, {
+    getRootNode: { enumerable: true },
+    hasChildNodes: { enumerable: true },
+    normalize: { enumerable: true },
+    cloneNode: { enumerable: true },
+    isEqualNode: { enumerable: true },
+    isSameNode: { enumerable: true },
+    compareDocumentPosition: { enumerable: true },
+    contains: { enumerable: true },
+    lookupPrefix: { enumerable: true },
+    lookupNamespaceURI: { enumerable: true },
+    isDefaultNamespace: { enumerable: true },
+    insertBefore: { enumerable: true },
+    appendChild: { enumerable: true },
+    replaceChild: { enumerable: true },
+    removeChild: { enumerable: true },
+    nodeType: { enumerable: true },
+    nodeName: { enumerable: true },
+    baseURI: { enumerable: true },
+    isConnected: { enumerable: true },
+    ownerDocument: { enumerable: true },
+    parentNode: { enumerable: true },
+    parentElement: { enumerable: true },
+    childNodes: { enumerable: true },
+    firstChild: { enumerable: true },
+    lastChild: { enumerable: true },
+    previousSibling: { enumerable: true },
+    nextSibling: { enumerable: true },
+    nodeValue: { enumerable: true },
+    textContent: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Node", configurable: true },
+    ELEMENT_NODE: { value: 1, enumerable: true },
+    ATTRIBUTE_NODE: { value: 2, enumerable: true },
+    TEXT_NODE: { value: 3, enumerable: true },
+    CDATA_SECTION_NODE: { value: 4, enumerable: true },
+    ENTITY_REFERENCE_NODE: { value: 5, enumerable: true },
+    ENTITY_NODE: { value: 6, enumerable: true },
+    PROCESSING_INSTRUCTION_NODE: { value: 7, enumerable: true },
+    COMMENT_NODE: { value: 8, enumerable: true },
+    DOCUMENT_NODE: { value: 9, enumerable: true },
+    DOCUMENT_TYPE_NODE: { value: 10, enumerable: true },
+    DOCUMENT_FRAGMENT_NODE: { value: 11, enumerable: true },
+    NOTATION_NODE: { value: 12, enumerable: true },
+    DOCUMENT_POSITION_DISCONNECTED: { value: 0x01, enumerable: true },
+    DOCUMENT_POSITION_PRECEDING: { value: 0x02, enumerable: true },
+    DOCUMENT_POSITION_FOLLOWING: { value: 0x04, enumerable: true },
+    DOCUMENT_POSITION_CONTAINS: { value: 0x08, enumerable: true },
+    DOCUMENT_POSITION_CONTAINED_BY: { value: 0x10, enumerable: true },
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: { value: 0x20, enumerable: true }
+  });
+  Object.defineProperties(Node, {
+    ELEMENT_NODE: { value: 1, enumerable: true },
+    ATTRIBUTE_NODE: { value: 2, enumerable: true },
+    TEXT_NODE: { value: 3, enumerable: true },
+    CDATA_SECTION_NODE: { value: 4, enumerable: true },
+    ENTITY_REFERENCE_NODE: { value: 5, enumerable: true },
+    ENTITY_NODE: { value: 6, enumerable: true },
+    PROCESSING_INSTRUCTION_NODE: { value: 7, enumerable: true },
+    COMMENT_NODE: { value: 8, enumerable: true },
+    DOCUMENT_NODE: { value: 9, enumerable: true },
+    DOCUMENT_TYPE_NODE: { value: 10, enumerable: true },
+    DOCUMENT_FRAGMENT_NODE: { value: 11, enumerable: true },
+    NOTATION_NODE: { value: 12, enumerable: true },
+    DOCUMENT_POSITION_DISCONNECTED: { value: 0x01, enumerable: true },
+    DOCUMENT_POSITION_PRECEDING: { value: 0x02, enumerable: true },
+    DOCUMENT_POSITION_FOLLOWING: { value: 0x04, enumerable: true },
+    DOCUMENT_POSITION_CONTAINS: { value: 0x08, enumerable: true },
+    DOCUMENT_POSITION_CONTAINED_BY: { value: 0x10, enumerable: true },
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: { value: 0x20, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Node;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Node
+  });
+};
+
+const Impl = require("../nodes/Node-impl.js");
diff --git a/lib/jsdom/living/generated/NodeIterator.js b/lib/jsdom/living/generated/NodeIterator.js
new file mode 100644
index 0000000..a281238
--- /dev/null
+++ b/lib/jsdom/living/generated/NodeIterator.js
@@ -0,0 +1,182 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "NodeIterator";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'NodeIterator'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["NodeIterator"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor NodeIterator is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class NodeIterator {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    nextNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].nextNode());
+    }
+
+    previousNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].previousNode());
+    }
+
+    detach() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].detach();
+    }
+
+    get root() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "root", () => {
+        return utils.tryWrapperForImpl(this[impl]["root"]);
+      });
+    }
+
+    get referenceNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["referenceNode"]);
+    }
+
+    get pointerBeforeReferenceNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["pointerBeforeReferenceNode"];
+    }
+
+    get whatToShow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["whatToShow"];
+    }
+
+    get filter() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["filter"]);
+    }
+  }
+  Object.defineProperties(NodeIterator.prototype, {
+    nextNode: { enumerable: true },
+    previousNode: { enumerable: true },
+    detach: { enumerable: true },
+    root: { enumerable: true },
+    referenceNode: { enumerable: true },
+    pointerBeforeReferenceNode: { enumerable: true },
+    whatToShow: { enumerable: true },
+    filter: { enumerable: true },
+    [Symbol.toStringTag]: { value: "NodeIterator", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = NodeIterator;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: NodeIterator
+  });
+};
+
+const Impl = require("../traversal/NodeIterator-impl.js");
diff --git a/lib/jsdom/living/generated/NodeList.js b/lib/jsdom/living/generated/NodeList.js
new file mode 100644
index 0000000..e9d323c
--- /dev/null
+++ b/lib/jsdom/living/generated/NodeList.js
@@ -0,0 +1,304 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "NodeList";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'NodeList'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["NodeList"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor NodeList is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class NodeList {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'item' on 'NodeList': 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 'NodeList': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+  }
+  Object.defineProperties(NodeList.prototype, {
+    item: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "NodeList", configurable: true },
+    [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true },
+    keys: { value: Array.prototype.keys, configurable: true, enumerable: true, writable: true },
+    values: { value: Array.prototype[Symbol.iterator], configurable: true, enumerable: true, writable: true },
+    entries: { value: Array.prototype.entries, configurable: true, enumerable: true, writable: true },
+    forEach: { value: Array.prototype.forEach, configurable: true, enumerable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = NodeList;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: NodeList
+  });
+};
+
+const proxyHandler = {
+  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[impl][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[impl].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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../nodes/NodeList-impl.js");
diff --git a/lib/jsdom/living/generated/PageTransitionEvent.js b/lib/jsdom/living/generated/PageTransitionEvent.js
new file mode 100644
index 0000000..bc56a2c
--- /dev/null
+++ b/lib/jsdom/living/generated/PageTransitionEvent.js
@@ -0,0 +1,144 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertPageTransitionEventInit = require("./PageTransitionEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "PageTransitionEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'PageTransitionEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["PageTransitionEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor PageTransitionEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate PageTransitionEvent before Event");
+  }
+  class PageTransitionEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertPageTransitionEventInit(curArg, {
+          context: "Failed to construct 'PageTransitionEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get persisted() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["persisted"];
+    }
+  }
+  Object.defineProperties(PageTransitionEvent.prototype, {
+    persisted: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PageTransitionEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = PageTransitionEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PageTransitionEvent
+  });
+};
+
+const Impl = require("../events/PageTransitionEvent-impl.js");
diff --git a/lib/jsdom/living/generated/PageTransitionEventInit.js b/lib/jsdom/living/generated/PageTransitionEventInit.js
new file mode 100644
index 0000000..235c126
--- /dev/null
+++ b/lib/jsdom/living/generated/PageTransitionEventInit.js
@@ -0,0 +1,32 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(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" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Performance.js b/lib/jsdom/living/generated/Performance.js
new file mode 100644
index 0000000..0c8fb4d
--- /dev/null
+++ b/lib/jsdom/living/generated/Performance.js
@@ -0,0 +1,141 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "Performance";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Performance'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Performance"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Performance is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  EventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.EventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate Performance before EventTarget");
+  }
+  class Performance extends globalObject.EventTarget {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    now() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].now());
+    }
+
+    toJSON() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].toJSON();
+    }
+
+    get timeOrigin() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["timeOrigin"]);
+    }
+  }
+  Object.defineProperties(Performance.prototype, {
+    now: { enumerable: true },
+    toJSON: { enumerable: true },
+    timeOrigin: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Performance", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Performance;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Performance
+  });
+};
+
+const Impl = require("../hr-time/Performance-impl.js");
diff --git a/lib/jsdom/living/generated/Plugin.js b/lib/jsdom/living/generated/Plugin.js
new file mode 100644
index 0000000..e8c3a6a
--- /dev/null
+++ b/lib/jsdom/living/generated/Plugin.js
@@ -0,0 +1,375 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Plugin";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Plugin'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Plugin"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Plugin is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Plugin {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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" });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    namedItem(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].namedItem(...args));
+    }
+
+    get name() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["name"];
+    }
+
+    get description() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["description"];
+    }
+
+    get filename() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["filename"];
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["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: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Plugin;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Plugin
+  });
+};
+
+const proxyHandler = {
+  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[impl][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of target[impl][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;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    const namedValue = target[impl].namedItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: false,
+        enumerable: false,
+        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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+
+      typeof P === "string" && !utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+    if (!utils.hasOwn(target, P)) {
+      const creating = !(target[impl].namedItem(P) !== null);
+      if (!creating) {
+        return false;
+      }
+    }
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    if (target[impl].namedItem(P) !== null && !(P in target)) {
+      return false;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../navigator/Plugin-impl.js");
diff --git a/lib/jsdom/living/generated/PluginArray.js b/lib/jsdom/living/generated/PluginArray.js
new file mode 100644
index 0000000..e8af060
--- /dev/null
+++ b/lib/jsdom/living/generated/PluginArray.js
@@ -0,0 +1,372 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "PluginArray";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'PluginArray'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["PluginArray"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor PluginArray is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class PluginArray {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    refresh() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'refresh' on 'PluginArray': parameter 1"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return this[impl].refresh(...args);
+    }
+
+    item(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].item(...args));
+    }
+
+    namedItem(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].namedItem(...args));
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["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: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = PluginArray;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PluginArray
+  });
+};
+
+const proxyHandler = {
+  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[impl][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of target[impl][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;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    const namedValue = target[impl].namedItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: false,
+        enumerable: false,
+        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);
+    }
+    if (target === receiver) {
+      utils.isArrayIndexPropName(P);
+
+      typeof P === "string" && !utils.isArrayIndexPropName(P);
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[impl].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+    if (!utils.hasOwn(target, P)) {
+      const creating = !(target[impl].namedItem(P) !== null);
+      if (!creating) {
+        return false;
+      }
+    }
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[impl].item(index) !== null);
+    }
+
+    if (target[impl].namedItem(P) !== null && !(P in target)) {
+      return false;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../navigator/PluginArray-impl.js");
diff --git a/lib/jsdom/living/generated/PopStateEvent.js b/lib/jsdom/living/generated/PopStateEvent.js
new file mode 100644
index 0000000..a5f6794
--- /dev/null
+++ b/lib/jsdom/living/generated/PopStateEvent.js
@@ -0,0 +1,140 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertPopStateEventInit = require("./PopStateEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "PopStateEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'PopStateEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["PopStateEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor PopStateEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate PopStateEvent before Event");
+  }
+  class PopStateEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new 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" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertPopStateEventInit(curArg, { context: "Failed to construct 'PopStateEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get state() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["state"];
+    }
+  }
+  Object.defineProperties(PopStateEvent.prototype, {
+    state: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PopStateEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = PopStateEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PopStateEvent
+  });
+};
+
+const Impl = require("../events/PopStateEvent-impl.js");
diff --git a/lib/jsdom/living/generated/PopStateEventInit.js b/lib/jsdom/living/generated/PopStateEventInit.js
new file mode 100644
index 0000000..6286e19
--- /dev/null
+++ b/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 = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(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" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/ProcessingInstruction.js b/lib/jsdom/living/generated/ProcessingInstruction.js
new file mode 100644
index 0000000..320ea2e
--- /dev/null
+++ b/lib/jsdom/living/generated/ProcessingInstruction.js
@@ -0,0 +1,123 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const CharacterData = require("./CharacterData.js");
+
+const interfaceName = "ProcessingInstruction";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'ProcessingInstruction'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["ProcessingInstruction"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor ProcessingInstruction is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  CharacterData._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.CharacterData === undefined) {
+    throw new Error("Internal error: attempting to evaluate ProcessingInstruction before CharacterData");
+  }
+  class ProcessingInstruction extends globalObject.CharacterData {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get target() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["target"];
+    }
+  }
+  Object.defineProperties(ProcessingInstruction.prototype, {
+    target: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ProcessingInstruction", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = ProcessingInstruction;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ProcessingInstruction
+  });
+};
+
+const Impl = require("../nodes/ProcessingInstruction-impl.js");
diff --git a/lib/jsdom/living/generated/ProgressEvent.js b/lib/jsdom/living/generated/ProgressEvent.js
new file mode 100644
index 0000000..207e50f
--- /dev/null
+++ b/lib/jsdom/living/generated/ProgressEvent.js
@@ -0,0 +1,158 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertProgressEventInit = require("./ProgressEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "ProgressEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'ProgressEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["ProgressEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor ProgressEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate ProgressEvent before Event");
+  }
+  class ProgressEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new 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" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertProgressEventInit(curArg, { context: "Failed to construct 'ProgressEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get lengthComputable() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["lengthComputable"];
+    }
+
+    get loaded() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["loaded"];
+    }
+
+    get total() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["total"];
+    }
+  }
+  Object.defineProperties(ProgressEvent.prototype, {
+    lengthComputable: { enumerable: true },
+    loaded: { enumerable: true },
+    total: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ProgressEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = ProgressEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ProgressEvent
+  });
+};
+
+const Impl = require("../events/ProgressEvent-impl.js");
diff --git a/lib/jsdom/living/generated/ProgressEventInit.js b/lib/jsdom/living/generated/ProgressEventInit.js
new file mode 100644
index 0000000..d15f75b
--- /dev/null
+++ b/lib/jsdom/living/generated/ProgressEventInit.js
@@ -0,0 +1,56 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(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" });
+
+      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" });
+
+      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" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Range.js b/lib/jsdom/living/generated/Range.js
new file mode 100644
index 0000000..33c2ccf
--- /dev/null
+++ b/lib/jsdom/living/generated/Range.js
@@ -0,0 +1,595 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertNode = require("./Node.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const AbstractRange = require("./AbstractRange.js");
+
+const interfaceName = "Range";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Range'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Range"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Range is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  AbstractRange._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.AbstractRange === undefined) {
+    throw new Error("Internal error: attempting to evaluate Range before AbstractRange");
+  }
+  class Range extends globalObject.AbstractRange {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    setStart(node, offset) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'setStart' on 'Range': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setStart(...args);
+    }
+
+    setEnd(node, offset) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'setEnd' on 'Range': 2 arguments required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setEnd(...args);
+    }
+
+    setStartBefore(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setStartBefore' on 'Range': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'setStartBefore' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].setStartBefore(...args);
+    }
+
+    setStartAfter(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setStartAfter' on 'Range': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'setStartAfter' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].setStartAfter(...args);
+    }
+
+    setEndBefore(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setEndBefore' on 'Range': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'setEndBefore' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].setEndBefore(...args);
+    }
+
+    setEndAfter(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'setEndAfter' on 'Range': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'setEndAfter' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].setEndAfter(...args);
+    }
+
+    collapse() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, { context: "Failed to execute 'collapse' on 'Range': parameter 1" });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return this[impl].collapse(...args);
+    }
+
+    selectNode(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'selectNode' on 'Range': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'selectNode' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].selectNode(...args);
+    }
+
+    selectNodeContents(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'selectNodeContents' on 'Range': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'selectNodeContents' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].selectNodeContents(...args);
+    }
+
+    compareBoundaryPoints(how, sourceRange) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = module.exports.convert(curArg, {
+          context: "Failed to execute 'compareBoundaryPoints' on 'Range': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].compareBoundaryPoints(...args);
+    }
+
+    deleteContents() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteContents();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    extractContents() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].extractContents());
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    cloneContents() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].cloneContents());
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    insertNode(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'insertNode' on 'Range': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'insertNode' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].insertNode(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    surroundContents(newParent) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'surroundContents' on 'Range': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'surroundContents' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].surroundContents(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    cloneRange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].cloneRange());
+    }
+
+    detach() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].detach();
+    }
+
+    isPointInRange(node, offset) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'isPointInRange' on 'Range': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].isPointInRange(...args);
+    }
+
+    comparePoint(node, offset) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'comparePoint' on 'Range': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].comparePoint(...args);
+    }
+
+    intersectsNode(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'intersectsNode' on 'Range': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'intersectsNode' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].intersectsNode(...args);
+    }
+
+    toString() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].toString();
+    }
+
+    createContextualFragment(fragment) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(this[impl].createContextualFragment(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get commonAncestorContainer() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["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 }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Range;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Range
+  });
+};
+
+const Impl = require("../range/Range-impl.js");
diff --git a/lib/jsdom/living/generated/SVGAnimatedString.js b/lib/jsdom/living/generated/SVGAnimatedString.js
new file mode 100644
index 0000000..2525781
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGAnimatedString.js
@@ -0,0 +1,138 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGAnimatedString";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGAnimatedString'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGAnimatedString"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGAnimatedString is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class SVGAnimatedString {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get baseVal() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["baseVal"];
+    }
+
+    set baseVal(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'baseVal' property on 'SVGAnimatedString': The provided value"
+      });
+
+      this[impl]["baseVal"] = V;
+    }
+
+    get animVal() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["animVal"];
+    }
+  }
+  Object.defineProperties(SVGAnimatedString.prototype, {
+    baseVal: { enumerable: true },
+    animVal: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGAnimatedString", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGAnimatedString;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGAnimatedString
+  });
+};
+
+const Impl = require("../svg/SVGAnimatedString-impl.js");
diff --git a/lib/jsdom/living/generated/SVGBoundingBoxOptions.js b/lib/jsdom/living/generated/SVGBoundingBoxOptions.js
new file mode 100644
index 0000000..d0ed3c4
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGBoundingBoxOptions.js
@@ -0,0 +1,64 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convertInherit = function convertInherit(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" });
+
+      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" });
+
+      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" });
+
+      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" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/SVGElement.js b/lib/jsdom/living/generated/SVGElement.js
new file mode 100644
index 0000000..ba2d8dc
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGElement.js
@@ -0,0 +1,1408 @@
+"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 impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Element = require("./Element.js");
+
+const interfaceName = "SVGElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Element._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Element === undefined) {
+    throw new Error("Internal error: attempting to evaluate SVGElement before Element");
+  }
+  class SVGElement extends globalObject.Element {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    focus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].focus();
+    }
+
+    blur() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].blur();
+    }
+
+    get className() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "className", () => {
+        return utils.tryWrapperForImpl(this[impl]["className"]);
+      });
+    }
+
+    get ownerSVGElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ownerSVGElement"]);
+    }
+
+    get viewportElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["viewportElement"]);
+    }
+
+    get style() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "style", () => {
+        return utils.tryWrapperForImpl(this[impl]["style"]);
+      });
+    }
+
+    set style(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      this.style.cssText = V;
+    }
+
+    get onabort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onabort"]);
+    }
+
+    set onabort(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onabort"] = V;
+    }
+
+    get onauxclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onauxclick"]);
+    }
+
+    set onauxclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onauxclick"] = V;
+    }
+
+    get onblur() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onblur"]);
+    }
+
+    set onblur(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onblur"] = V;
+    }
+
+    get oncancel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncancel"]);
+    }
+
+    set oncancel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncancel"] = V;
+    }
+
+    get oncanplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncanplay"]);
+    }
+
+    set oncanplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncanplay"] = V;
+    }
+
+    get oncanplaythrough() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncanplaythrough"]);
+    }
+
+    set oncanplaythrough(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncanplaythrough"] = V;
+    }
+
+    get onchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onchange"]);
+    }
+
+    set onchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onchange"] = V;
+    }
+
+    get onclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclick"]);
+    }
+
+    set onclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclick"] = V;
+    }
+
+    get onclose() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclose"]);
+    }
+
+    set onclose(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclose"] = V;
+    }
+
+    get oncontextmenu() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncontextmenu"]);
+    }
+
+    set oncontextmenu(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncontextmenu"] = V;
+    }
+
+    get oncuechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oncuechange"]);
+    }
+
+    set oncuechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oncuechange"] = V;
+    }
+
+    get ondblclick() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondblclick"]);
+    }
+
+    set ondblclick(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondblclick"] = V;
+    }
+
+    get ondrag() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondrag"]);
+    }
+
+    set ondrag(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondrag"] = V;
+    }
+
+    get ondragend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragend"]);
+    }
+
+    set ondragend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragend"] = V;
+    }
+
+    get ondragenter() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragenter"]);
+    }
+
+    set ondragenter(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragenter"] = V;
+    }
+
+    get ondragexit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragexit"]);
+    }
+
+    set ondragexit(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragexit"] = V;
+    }
+
+    get ondragleave() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragleave"]);
+    }
+
+    set ondragleave(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragleave"] = V;
+    }
+
+    get ondragover() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragover"]);
+    }
+
+    set ondragover(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragover"] = V;
+    }
+
+    get ondragstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondragstart"]);
+    }
+
+    set ondragstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondragstart"] = V;
+    }
+
+    get ondrop() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondrop"]);
+    }
+
+    set ondrop(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondrop"] = V;
+    }
+
+    get ondurationchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ondurationchange"]);
+    }
+
+    set ondurationchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ondurationchange"] = V;
+    }
+
+    get onemptied() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onemptied"]);
+    }
+
+    set onemptied(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onemptied"] = V;
+    }
+
+    get onended() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onended"]);
+    }
+
+    set onended(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onended"] = V;
+    }
+
+    get onerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onerror"]);
+    }
+
+    set onerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onerror"] = V;
+    }
+
+    get onfocus() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onfocus"]);
+    }
+
+    set onfocus(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onfocus"] = V;
+    }
+
+    get oninput() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oninput"]);
+    }
+
+    set oninput(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oninput"] = V;
+    }
+
+    get oninvalid() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["oninvalid"]);
+    }
+
+    set oninvalid(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["oninvalid"] = V;
+    }
+
+    get onkeydown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeydown"]);
+    }
+
+    set onkeydown(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeydown"] = V;
+    }
+
+    get onkeypress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeypress"]);
+    }
+
+    set onkeypress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeypress"] = V;
+    }
+
+    get onkeyup() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onkeyup"]);
+    }
+
+    set onkeyup(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onkeyup"] = V;
+    }
+
+    get onload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onload"]);
+    }
+
+    set onload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onload"] = V;
+    }
+
+    get onloadeddata() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadeddata"]);
+    }
+
+    set onloadeddata(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadeddata"] = V;
+    }
+
+    get onloadedmetadata() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadedmetadata"]);
+    }
+
+    set onloadedmetadata(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadedmetadata"] = V;
+    }
+
+    get onloadend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadend"]);
+    }
+
+    set onloadend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadend"] = V;
+    }
+
+    get onloadstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadstart"]);
+    }
+
+    set onloadstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadstart"] = V;
+    }
+
+    get onmousedown() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmousedown"]);
+    }
+
+    set onmousedown(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmousedown"] = V;
+    }
+
+    get onmouseenter() {
+      return utils.tryWrapperForImpl(this[impl]["onmouseenter"]);
+    }
+
+    set onmouseenter(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseenter"] = V;
+    }
+
+    get onmouseleave() {
+      return utils.tryWrapperForImpl(this[impl]["onmouseleave"]);
+    }
+
+    set onmouseleave(V) {
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseleave"] = V;
+    }
+
+    get onmousemove() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmousemove"]);
+    }
+
+    set onmousemove(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmousemove"] = V;
+    }
+
+    get onmouseout() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseout"]);
+    }
+
+    set onmouseout(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseout"] = V;
+    }
+
+    get onmouseover() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseover"]);
+    }
+
+    set onmouseover(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseover"] = V;
+    }
+
+    get onmouseup() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmouseup"]);
+    }
+
+    set onmouseup(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmouseup"] = V;
+    }
+
+    get onwheel() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onwheel"]);
+    }
+
+    set onwheel(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onwheel"] = V;
+    }
+
+    get onpause() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpause"]);
+    }
+
+    set onpause(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpause"] = V;
+    }
+
+    get onplay() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onplay"]);
+    }
+
+    set onplay(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onplay"] = V;
+    }
+
+    get onplaying() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onplaying"]);
+    }
+
+    set onplaying(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onplaying"] = V;
+    }
+
+    get onprogress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onprogress"]);
+    }
+
+    set onprogress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onprogress"] = V;
+    }
+
+    get onratechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onratechange"]);
+    }
+
+    set onratechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onratechange"] = V;
+    }
+
+    get onreset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onreset"]);
+    }
+
+    set onreset(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onreset"] = V;
+    }
+
+    get onresize() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onresize"]);
+    }
+
+    set onresize(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onresize"] = V;
+    }
+
+    get onscroll() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onscroll"]);
+    }
+
+    set onscroll(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onscroll"] = V;
+    }
+
+    get onsecuritypolicyviolation() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsecuritypolicyviolation"]);
+    }
+
+    set onsecuritypolicyviolation(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsecuritypolicyviolation"] = V;
+    }
+
+    get onseeked() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onseeked"]);
+    }
+
+    set onseeked(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onseeked"] = V;
+    }
+
+    get onseeking() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onseeking"]);
+    }
+
+    set onseeking(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onseeking"] = V;
+    }
+
+    get onselect() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onselect"]);
+    }
+
+    set onselect(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onselect"] = V;
+    }
+
+    get onstalled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onstalled"]);
+    }
+
+    set onstalled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onstalled"] = V;
+    }
+
+    get onsubmit() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsubmit"]);
+    }
+
+    set onsubmit(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsubmit"] = V;
+    }
+
+    get onsuspend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onsuspend"]);
+    }
+
+    set onsuspend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onsuspend"] = V;
+    }
+
+    get ontimeupdate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontimeupdate"]);
+    }
+
+    set ontimeupdate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontimeupdate"] = V;
+    }
+
+    get ontoggle() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontoggle"]);
+    }
+
+    set ontoggle(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontoggle"] = V;
+    }
+
+    get onvolumechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onvolumechange"]);
+    }
+
+    set onvolumechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onvolumechange"] = V;
+    }
+
+    get onwaiting() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onwaiting"]);
+    }
+
+    set onwaiting(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onwaiting"] = V;
+    }
+
+    get dataset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "dataset", () => {
+        return utils.tryWrapperForImpl(this[impl]["dataset"]);
+      });
+    }
+
+    get nonce() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      const value = this[impl].getAttributeNS(null, "nonce");
+      return value === null ? "" : value;
+    }
+
+    set nonce(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'nonce' property on 'SVGElement': The provided value"
+      });
+
+      this[impl].setAttributeNS(null, "nonce", V);
+    }
+
+    get tabIndex() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["tabIndex"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set tabIndex(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["long"](V, {
+        context: "Failed to set the 'tabIndex' property on 'SVGElement': The provided value"
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["tabIndex"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+  }
+  Object.defineProperties(SVGElement.prototype, {
+    focus: { enumerable: true },
+    blur: { enumerable: true },
+    className: { enumerable: true },
+    ownerSVGElement: { enumerable: true },
+    viewportElement: { enumerable: true },
+    style: { enumerable: true },
+    onabort: { enumerable: true },
+    onauxclick: { enumerable: true },
+    onblur: { enumerable: true },
+    oncancel: { enumerable: true },
+    oncanplay: { enumerable: true },
+    oncanplaythrough: { enumerable: true },
+    onchange: { enumerable: true },
+    onclick: { enumerable: true },
+    onclose: { enumerable: true },
+    oncontextmenu: { enumerable: true },
+    oncuechange: { enumerable: true },
+    ondblclick: { enumerable: true },
+    ondrag: { enumerable: true },
+    ondragend: { enumerable: true },
+    ondragenter: { enumerable: true },
+    ondragexit: { enumerable: true },
+    ondragleave: { enumerable: true },
+    ondragover: { enumerable: true },
+    ondragstart: { enumerable: true },
+    ondrop: { enumerable: true },
+    ondurationchange: { enumerable: true },
+    onemptied: { enumerable: true },
+    onended: { enumerable: true },
+    onerror: { enumerable: true },
+    onfocus: { enumerable: true },
+    oninput: { enumerable: true },
+    oninvalid: { enumerable: true },
+    onkeydown: { enumerable: true },
+    onkeypress: { enumerable: true },
+    onkeyup: { enumerable: true },
+    onload: { enumerable: true },
+    onloadeddata: { enumerable: true },
+    onloadedmetadata: { enumerable: true },
+    onloadend: { enumerable: true },
+    onloadstart: { enumerable: true },
+    onmousedown: { enumerable: true },
+    onmouseenter: { enumerable: true },
+    onmouseleave: { enumerable: true },
+    onmousemove: { enumerable: true },
+    onmouseout: { enumerable: true },
+    onmouseover: { enumerable: true },
+    onmouseup: { enumerable: true },
+    onwheel: { enumerable: true },
+    onpause: { enumerable: true },
+    onplay: { enumerable: true },
+    onplaying: { enumerable: true },
+    onprogress: { enumerable: true },
+    onratechange: { enumerable: true },
+    onreset: { enumerable: true },
+    onresize: { enumerable: true },
+    onscroll: { enumerable: true },
+    onsecuritypolicyviolation: { enumerable: true },
+    onseeked: { enumerable: true },
+    onseeking: { enumerable: true },
+    onselect: { enumerable: true },
+    onstalled: { enumerable: true },
+    onsubmit: { enumerable: true },
+    onsuspend: { enumerable: true },
+    ontimeupdate: { enumerable: true },
+    ontoggle: { enumerable: true },
+    onvolumechange: { enumerable: true },
+    onwaiting: { enumerable: true },
+    dataset: { enumerable: true },
+    nonce: { enumerable: true },
+    tabIndex: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGElement
+  });
+};
+
+const Impl = require("../nodes/SVGElement-impl.js");
diff --git a/lib/jsdom/living/generated/SVGGraphicsElement.js b/lib/jsdom/living/generated/SVGGraphicsElement.js
new file mode 100644
index 0000000..2558933
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGGraphicsElement.js
@@ -0,0 +1,136 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const SVGElement = require("./SVGElement.js");
+
+const interfaceName = "SVGGraphicsElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGGraphicsElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGGraphicsElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGGraphicsElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  SVGElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.SVGElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate SVGGraphicsElement before SVGElement");
+  }
+  class SVGGraphicsElement extends globalObject.SVGElement {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get requiredExtensions() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "requiredExtensions", () => {
+        return utils.tryWrapperForImpl(this[impl]["requiredExtensions"]);
+      });
+    }
+
+    get systemLanguage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "systemLanguage", () => {
+        return utils.tryWrapperForImpl(this[impl]["systemLanguage"]);
+      });
+    }
+  }
+  Object.defineProperties(SVGGraphicsElement.prototype, {
+    requiredExtensions: { enumerable: true },
+    systemLanguage: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGGraphicsElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGGraphicsElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGGraphicsElement
+  });
+};
+
+const Impl = require("../nodes/SVGGraphicsElement-impl.js");
diff --git a/lib/jsdom/living/generated/SVGNumber.js b/lib/jsdom/living/generated/SVGNumber.js
new file mode 100644
index 0000000..20c9495
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGNumber.js
@@ -0,0 +1,127 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGNumber";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGNumber'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGNumber"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGNumber is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class SVGNumber {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get value() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["value"];
+    }
+
+    set value(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["float"](V, { context: "Failed to set the 'value' property on 'SVGNumber': The provided value" });
+
+      this[impl]["value"] = V;
+    }
+  }
+  Object.defineProperties(SVGNumber.prototype, {
+    value: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGNumber", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGNumber;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGNumber
+  });
+};
+
+const Impl = require("../svg/SVGNumber-impl.js");
diff --git a/lib/jsdom/living/generated/SVGSVGElement.js b/lib/jsdom/living/generated/SVGSVGElement.js
new file mode 100644
index 0000000..66a0fd4
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGSVGElement.js
@@ -0,0 +1,517 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const SVGGraphicsElement = require("./SVGGraphicsElement.js");
+
+const interfaceName = "SVGSVGElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGSVGElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGSVGElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGSVGElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  SVGGraphicsElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.SVGGraphicsElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate SVGSVGElement before SVGGraphicsElement");
+  }
+  class SVGSVGElement extends globalObject.SVGGraphicsElement {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    createSVGNumber() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].createSVGNumber());
+    }
+
+    getElementById(elementId) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getElementById(...args));
+    }
+
+    suspendRedraw(maxWaitMilliseconds) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].suspendRedraw(...args);
+    }
+
+    unsuspendRedraw(suspendHandleID) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].unsuspendRedraw(...args);
+    }
+
+    unsuspendRedrawAll() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].unsuspendRedrawAll();
+    }
+
+    forceRedraw() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].forceRedraw();
+    }
+
+    get onafterprint() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onafterprint"]);
+    }
+
+    set onafterprint(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onafterprint"] = V;
+    }
+
+    get onbeforeprint() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onbeforeprint"]);
+    }
+
+    set onbeforeprint(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onbeforeprint"] = V;
+    }
+
+    get onbeforeunload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onbeforeunload"]);
+    }
+
+    set onbeforeunload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onbeforeunload"] = V;
+    }
+
+    get onhashchange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onhashchange"]);
+    }
+
+    set onhashchange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onhashchange"] = V;
+    }
+
+    get onlanguagechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onlanguagechange"]);
+    }
+
+    set onlanguagechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onlanguagechange"] = V;
+    }
+
+    get onmessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessage"]);
+    }
+
+    set onmessage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessage"] = V;
+    }
+
+    get onmessageerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessageerror"]);
+    }
+
+    set onmessageerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessageerror"] = V;
+    }
+
+    get onoffline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onoffline"]);
+    }
+
+    set onoffline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onoffline"] = V;
+    }
+
+    get ononline() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ononline"]);
+    }
+
+    set ononline(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ononline"] = V;
+    }
+
+    get onpagehide() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpagehide"]);
+    }
+
+    set onpagehide(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpagehide"] = V;
+    }
+
+    get onpageshow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpageshow"]);
+    }
+
+    set onpageshow(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpageshow"] = V;
+    }
+
+    get onpopstate() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onpopstate"]);
+    }
+
+    set onpopstate(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onpopstate"] = V;
+    }
+
+    get onrejectionhandled() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onrejectionhandled"]);
+    }
+
+    set onrejectionhandled(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onrejectionhandled"] = V;
+    }
+
+    get onstorage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onstorage"]);
+    }
+
+    set onstorage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onstorage"] = V;
+    }
+
+    get onunhandledrejection() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onunhandledrejection"]);
+    }
+
+    set onunhandledrejection(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onunhandledrejection"] = V;
+    }
+
+    get onunload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onunload"]);
+    }
+
+    set onunload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onunload"] = V;
+    }
+  }
+  Object.defineProperties(SVGSVGElement.prototype, {
+    createSVGNumber: { enumerable: true },
+    getElementById: { enumerable: true },
+    suspendRedraw: { enumerable: true },
+    unsuspendRedraw: { enumerable: true },
+    unsuspendRedrawAll: { enumerable: true },
+    forceRedraw: { 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 }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGSVGElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGSVGElement
+  });
+};
+
+const Impl = require("../nodes/SVGSVGElement-impl.js");
diff --git a/lib/jsdom/living/generated/SVGStringList.js b/lib/jsdom/living/generated/SVGStringList.js
new file mode 100644
index 0000000..47aae34
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGStringList.js
@@ -0,0 +1,490 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGStringList";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGStringList'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGStringList"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGStringList is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class SVGStringList {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    clear() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].clear();
+    }
+
+    initialize(newItem) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].initialize(...args);
+    }
+
+    getItem(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].getItem(...args);
+    }
+
+    insertItemBefore(newItem, index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'insertItemBefore' on 'SVGStringList': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].insertItemBefore(...args);
+    }
+
+    replaceItem(newItem, index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'replaceItem' on 'SVGStringList': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].replaceItem(...args);
+    }
+
+    removeItem(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].removeItem(...args);
+    }
+
+    appendItem(newItem) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].appendItem(...args);
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["length"];
+    }
+
+    get numberOfItems() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["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: Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGStringList;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGStringList
+  });
+};
+
+const proxyHandler = {
+  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[impl][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[impl][utils.supportsPropertyIndex](index)) {
+        const indexedValue = target[impl].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);
+    }
+    if (target === receiver) {
+      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"
+        });
+
+        const creating = !target[impl][utils.supportsPropertyIndex](index);
+        if (creating) {
+          target[impl][utils.indexedSetNew](index, indexedValue);
+        } else {
+          target[impl][utils.indexedSetExisting](index, indexedValue);
+        }
+
+        return true;
+      }
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+
+      if (target[impl][utils.supportsPropertyIndex](index)) {
+        const indexedValue = target[impl].getItem(index);
+        ownDesc = {
+          writable: true,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    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"
+      });
+
+      const creating = !target[impl][utils.supportsPropertyIndex](index);
+      if (creating) {
+        target[impl][utils.indexedSetNew](index, indexedValue);
+      } else {
+        target[impl][utils.indexedSetExisting](index, indexedValue);
+      }
+
+      return true;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !target[impl][utils.supportsPropertyIndex](index);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../svg/SVGStringList-impl.js");
diff --git a/lib/jsdom/living/generated/SVGTitleElement.js b/lib/jsdom/living/generated/SVGTitleElement.js
new file mode 100644
index 0000000..c22db2b
--- /dev/null
+++ b/lib/jsdom/living/generated/SVGTitleElement.js
@@ -0,0 +1,114 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const SVGElement = require("./SVGElement.js");
+
+const interfaceName = "SVGTitleElement";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'SVGTitleElement'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["SVGTitleElement"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor SVGTitleElement is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  SVGElement._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.SVGElement === undefined) {
+    throw new Error("Internal error: attempting to evaluate SVGTitleElement before SVGElement");
+  }
+  class SVGTitleElement extends globalObject.SVGElement {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGTitleElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGTitleElement", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = SVGTitleElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGTitleElement
+  });
+};
+
+const Impl = require("../nodes/SVGTitleElement-impl.js");
diff --git a/lib/jsdom/living/generated/Screen.js b/lib/jsdom/living/generated/Screen.js
new file mode 100644
index 0000000..1b294f5
--- /dev/null
+++ b/lib/jsdom/living/generated/Screen.js
@@ -0,0 +1,162 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Screen";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Screen'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Screen"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Screen is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Screen {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get availWidth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["availWidth"];
+    }
+
+    get availHeight() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["availHeight"];
+    }
+
+    get width() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["width"];
+    }
+
+    get height() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["height"];
+    }
+
+    get colorDepth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["colorDepth"];
+    }
+
+    get pixelDepth() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["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 }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Screen;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Screen
+  });
+};
+
+const Impl = require("../window/Screen-impl.js");
diff --git a/lib/jsdom/living/generated/ScrollBehavior.js b/lib/jsdom/living/generated/ScrollBehavior.js
new file mode 100644
index 0000000..a1df43e
--- /dev/null
+++ b/lib/jsdom/living/generated/ScrollBehavior.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["auto", "instant", "smooth"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for ScrollBehavior`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/ScrollIntoViewOptions.js b/lib/jsdom/living/generated/ScrollIntoViewOptions.js
new file mode 100644
index 0000000..d969c79
--- /dev/null
+++ b/lib/jsdom/living/generated/ScrollIntoViewOptions.js
@@ -0,0 +1,45 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertScrollLogicalPosition = require("./ScrollLogicalPosition.js").convert;
+const ScrollOptions = require("./ScrollOptions.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  ScrollOptions.convertInherit(obj, ret, { context });
+
+  {
+    const key = "block";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = convertScrollLogicalPosition(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 = convertScrollLogicalPosition(value, { context: context + " has member inline that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "nearest";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/ScrollLogicalPosition.js b/lib/jsdom/living/generated/ScrollLogicalPosition.js
new file mode 100644
index 0000000..7a6ef4d
--- /dev/null
+++ b/lib/jsdom/living/generated/ScrollLogicalPosition.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["start", "center", "end", "nearest"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for ScrollLogicalPosition`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/ScrollOptions.js b/lib/jsdom/living/generated/ScrollOptions.js
new file mode 100644
index 0000000..62de8fc
--- /dev/null
+++ b/lib/jsdom/living/generated/ScrollOptions.js
@@ -0,0 +1,30 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertScrollBehavior = require("./ScrollBehavior.js").convert;
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "behavior";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = convertScrollBehavior(value, { context: context + " has member behavior that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "auto";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/ScrollRestoration.js b/lib/jsdom/living/generated/ScrollRestoration.js
new file mode 100644
index 0000000..49d1d98
--- /dev/null
+++ b/lib/jsdom/living/generated/ScrollRestoration.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["auto", "manual"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for ScrollRestoration`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/Selection.js b/lib/jsdom/living/generated/Selection.js
new file mode 100644
index 0000000..e3c96d9
--- /dev/null
+++ b/lib/jsdom/living/generated/Selection.js
@@ -0,0 +1,499 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertRange = require("./Range.js").convert;
+const convertNode = require("./Node.js").convert;
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Selection";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Selection'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Selection"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Selection is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Selection {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    getRangeAt(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].getRangeAt(...args));
+    }
+
+    addRange(range) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'addRange' on 'Selection': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertRange(curArg, { context: "Failed to execute 'addRange' on 'Selection': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].addRange(...args);
+    }
+
+    removeRange(range) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'removeRange' on 'Selection': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertRange(curArg, { context: "Failed to execute 'removeRange' on 'Selection': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].removeRange(...args);
+    }
+
+    removeAllRanges() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].removeAllRanges();
+    }
+
+    empty() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].empty();
+    }
+
+    collapse(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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 = convertNode(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"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return this[impl].collapse(...args);
+    }
+
+    setPosition(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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 = convertNode(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"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return this[impl].setPosition(...args);
+    }
+
+    collapseToStart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].collapseToStart();
+    }
+
+    collapseToEnd() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].collapseToEnd();
+    }
+
+    extend(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'extend' on 'Selection': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return this[impl].extend(...args);
+    }
+
+    setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 4) {
+        throw new TypeError(
+          "Failed to execute 'setBaseAndExtent' on 'Selection': 4 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = convertNode(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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setBaseAndExtent(...args);
+    }
+
+    selectAllChildren(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'selectAllChildren' on 'Selection': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, { context: "Failed to execute 'selectAllChildren' on 'Selection': parameter 1" });
+        args.push(curArg);
+      }
+      return this[impl].selectAllChildren(...args);
+    }
+
+    deleteFromDocument() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl].deleteFromDocument();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    containsNode(node) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'containsNode' on 'Selection': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(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"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return this[impl].containsNode(...args);
+    }
+
+    toString() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].toString();
+    }
+
+    get anchorNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["anchorNode"]);
+    }
+
+    get anchorOffset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["anchorOffset"];
+    }
+
+    get focusNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["focusNode"]);
+    }
+
+    get focusOffset() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["focusOffset"];
+    }
+
+    get isCollapsed() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["isCollapsed"];
+    }
+
+    get rangeCount() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["rangeCount"];
+    }
+
+    get type() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["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 }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Selection;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Selection
+  });
+};
+
+const Impl = require("../selection/Selection-impl.js");
diff --git a/lib/jsdom/living/generated/SelectionMode.js b/lib/jsdom/living/generated/SelectionMode.js
new file mode 100644
index 0000000..d000f90
--- /dev/null
+++ b/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 = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for SelectionMode`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/ShadowRoot.js b/lib/jsdom/living/generated/ShadowRoot.js
new file mode 100644
index 0000000..05b886f
--- /dev/null
+++ b/lib/jsdom/living/generated/ShadowRoot.js
@@ -0,0 +1,175 @@
+"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 impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const DocumentFragment = require("./DocumentFragment.js");
+
+const interfaceName = "ShadowRoot";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'ShadowRoot'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["ShadowRoot"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor ShadowRoot is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  DocumentFragment._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.DocumentFragment === undefined) {
+    throw new Error("Internal error: attempting to evaluate ShadowRoot before DocumentFragment");
+  }
+  class ShadowRoot extends globalObject.DocumentFragment {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get mode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["mode"]);
+    }
+
+    get host() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["host"]);
+    }
+
+    get innerHTML() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return this[impl]["innerHTML"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set innerHTML(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'innerHTML' property on 'ShadowRoot': The provided value",
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        this[impl]["innerHTML"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get activeElement() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["activeElement"]);
+    }
+  }
+  Object.defineProperties(ShadowRoot.prototype, {
+    mode: { enumerable: true },
+    host: { enumerable: true },
+    innerHTML: { enumerable: true },
+    activeElement: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ShadowRoot", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = ShadowRoot;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ShadowRoot
+  });
+};
+
+const Impl = require("../nodes/ShadowRoot-impl.js");
diff --git a/lib/jsdom/living/generated/ShadowRootInit.js b/lib/jsdom/living/generated/ShadowRootInit.js
new file mode 100644
index 0000000..39a9024
--- /dev/null
+++ b/lib/jsdom/living/generated/ShadowRootInit.js
@@ -0,0 +1,30 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertShadowRootMode = require("./ShadowRootMode.js").convert;
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "mode";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = convertShadowRootMode(value, { context: context + " has member mode that" });
+
+      ret[key] = value;
+    } else {
+      throw new TypeError("mode is required in 'ShadowRootInit'");
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/ShadowRootMode.js b/lib/jsdom/living/generated/ShadowRootMode.js
new file mode 100644
index 0000000..7b7cdb9
--- /dev/null
+++ b/lib/jsdom/living/generated/ShadowRootMode.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["open", "closed"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for ShadowRootMode`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/StaticRange.js b/lib/jsdom/living/generated/StaticRange.js
new file mode 100644
index 0000000..e65377d
--- /dev/null
+++ b/lib/jsdom/living/generated/StaticRange.js
@@ -0,0 +1,126 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertStaticRangeInit = require("./StaticRangeInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const AbstractRange = require("./AbstractRange.js");
+
+const interfaceName = "StaticRange";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'StaticRange'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["StaticRange"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor StaticRange is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  AbstractRange._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.AbstractRange === undefined) {
+    throw new Error("Internal error: attempting to evaluate StaticRange before AbstractRange");
+  }
+  class StaticRange extends globalObject.AbstractRange {
+    constructor(init) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'StaticRange': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertStaticRangeInit(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 }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = StaticRange;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: StaticRange
+  });
+};
+
+const Impl = require("../range/StaticRange-impl.js");
diff --git a/lib/jsdom/living/generated/StaticRangeInit.js b/lib/jsdom/living/generated/StaticRangeInit.js
new file mode 100644
index 0000000..c8f324a
--- /dev/null
+++ b/lib/jsdom/living/generated/StaticRangeInit.js
@@ -0,0 +1,66 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertNode = require("./Node.js").convert;
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  {
+    const key = "endContainer";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = convertNode(value, { context: context + " has member endContainer that" });
+
+      ret[key] = value;
+    } else {
+      throw new 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" });
+
+      ret[key] = value;
+    } else {
+      throw new TypeError("endOffset is required in 'StaticRangeInit'");
+    }
+  }
+
+  {
+    const key = "startContainer";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = convertNode(value, { context: context + " has member startContainer that" });
+
+      ret[key] = value;
+    } else {
+      throw new 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" });
+
+      ret[key] = value;
+    } else {
+      throw new TypeError("startOffset is required in 'StaticRangeInit'");
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/Storage.js b/lib/jsdom/living/generated/Storage.js
new file mode 100644
index 0000000..d92c09a
--- /dev/null
+++ b/lib/jsdom/living/generated/Storage.js
@@ -0,0 +1,379 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "Storage";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Storage'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Storage"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Storage is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj = new Proxy(obj, proxyHandler);
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class Storage {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    key(index) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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" });
+        args.push(curArg);
+      }
+      return this[impl].key(...args);
+    }
+
+    getItem(key) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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" });
+        args.push(curArg);
+      }
+      return this[impl].getItem(...args);
+    }
+
+    setItem(key, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new 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" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to execute 'setItem' on 'Storage': parameter 2" });
+        args.push(curArg);
+      }
+      return this[impl].setItem(...args);
+    }
+
+    removeItem(key) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new 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"
+        });
+        args.push(curArg);
+      }
+      return this[impl].removeItem(...args);
+    }
+
+    clear() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].clear();
+    }
+
+    get length() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["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 }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Storage;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Storage
+  });
+};
+
+const proxyHandler = {
+  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[impl][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[impl].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);
+    }
+    if (target === receiver) {
+      if (typeof P === "string" && !utils.isArrayIndexPropName(P)) {
+        let namedValue = V;
+
+        namedValue = conversions["DOMString"](namedValue, {
+          context: "Failed to set the '" + P + "' property on 'Storage': The provided value"
+        });
+
+        target[impl].setItem(P, namedValue);
+
+        return true;
+      }
+    }
+    let ownDesc;
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    if (ownDesc === undefined) {
+      const parent = Reflect.getPrototypeOf(target);
+      if (parent !== null) {
+        return Reflect.set(parent, P, V, receiver);
+      }
+      ownDesc = { writable: true, enumerable: true, configurable: true, value: undefined };
+    }
+    if (!ownDesc.writable) {
+      return false;
+    }
+    if (!utils.isObject(receiver)) {
+      return false;
+    }
+    const existingDesc = Reflect.getOwnPropertyDescriptor(receiver, P);
+    let valueDesc;
+    if (existingDesc !== undefined) {
+      if (existingDesc.get || existingDesc.set) {
+        return false;
+      }
+      if (!existingDesc.writable) {
+        return false;
+      }
+      valueDesc = { value: V };
+    } else {
+      valueDesc = { writable: true, enumerable: true, configurable: true, value: V };
+    }
+    return Reflect.defineProperty(receiver, P, valueDesc);
+  },
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+    if (!utils.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"
+      });
+
+      target[impl].setItem(P, namedValue);
+
+      return true;
+    }
+    return Reflect.defineProperty(target, P, desc);
+  },
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    if (target[impl].getItem(P) !== null && !(P in target)) {
+      target[impl].removeItem(P);
+      return true;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  },
+
+  preventExtensions() {
+    return false;
+  }
+};
+
+const Impl = require("../webstorage/Storage-impl.js");
diff --git a/lib/jsdom/living/generated/StorageEvent.js b/lib/jsdom/living/generated/StorageEvent.js
new file mode 100644
index 0000000..39a3157
--- /dev/null
+++ b/lib/jsdom/living/generated/StorageEvent.js
@@ -0,0 +1,294 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertStorageEventInit = require("./StorageEventInit.js").convert;
+const convertStorage = require("./Storage.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "StorageEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'StorageEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["StorageEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor StorageEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate StorageEvent before Event");
+  }
+  class StorageEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'StorageEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'StorageEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertStorageEventInit(curArg, { context: "Failed to construct 'StorageEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    initStorageEvent(type) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initStorageEvent' on 'StorageEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 4"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[4];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 5"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[5];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = conversions["DOMString"](curArg, {
+              context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 6"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[6];
+        if (curArg !== undefined) {
+          curArg = conversions["USVString"](curArg, {
+            context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 7"
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[7];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = convertStorage(curArg, {
+              context: "Failed to execute 'initStorageEvent' on 'StorageEvent': parameter 8"
+            });
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return this[impl].initStorageEvent(...args);
+    }
+
+    get key() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["key"];
+    }
+
+    get oldValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["oldValue"];
+    }
+
+    get newValue() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["newValue"];
+    }
+
+    get url() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["url"];
+    }
+
+    get storageArea() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["storageArea"]);
+    }
+  }
+  Object.defineProperties(StorageEvent.prototype, {
+    initStorageEvent: { enumerable: true },
+    key: { enumerable: true },
+    oldValue: { enumerable: true },
+    newValue: { enumerable: true },
+    url: { enumerable: true },
+    storageArea: { enumerable: true },
+    [Symbol.toStringTag]: { value: "StorageEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = StorageEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: StorageEvent
+  });
+};
+
+const Impl = require("../events/StorageEvent-impl.js");
diff --git a/lib/jsdom/living/generated/StorageEventInit.js b/lib/jsdom/living/generated/StorageEventInit.js
new file mode 100644
index 0000000..0f7f80f
--- /dev/null
+++ b/lib/jsdom/living/generated/StorageEventInit.js
@@ -0,0 +1,93 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertStorage = require("./Storage.js").convert;
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "key";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = conversions["DOMString"](value, { context: context + " has member key that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "newValue";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = conversions["DOMString"](value, { context: context + " has member newValue that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "oldValue";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = conversions["DOMString"](value, { context: context + " has member oldValue that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "storageArea";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = convertStorage(value, { context: context + " has member storageArea that" });
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "url";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["USVString"](value, { context: context + " has member url that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/SupportedType.js b/lib/jsdom/living/generated/SupportedType.js
new file mode 100644
index 0000000..668ee55
--- /dev/null
+++ b/lib/jsdom/living/generated/SupportedType.js
@@ -0,0 +1,18 @@
+"use strict";
+
+const enumerationValues = new Set([
+  "text/html",
+  "text/xml",
+  "application/xml",
+  "application/xhtml+xml",
+  "image/svg+xml"
+]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for SupportedType`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/Text.js b/lib/jsdom/living/generated/Text.js
new file mode 100644
index 0000000..bd02cc8
--- /dev/null
+++ b/lib/jsdom/living/generated/Text.js
@@ -0,0 +1,164 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const CharacterData = require("./CharacterData.js");
+
+const interfaceName = "Text";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'Text'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["Text"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor Text is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  CharacterData._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.CharacterData === undefined) {
+    throw new Error("Internal error: attempting to evaluate Text before CharacterData");
+  }
+  class Text extends globalObject.CharacterData {
+    constructor() {
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'Text': parameter 1" });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    splitText(offset) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'splitText' on 'Text': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'splitText' on 'Text': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(this[impl].splitText(...args));
+    }
+
+    get wholeText() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["wholeText"];
+    }
+
+    get assignedSlot() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["assignedSlot"]);
+    }
+  }
+  Object.defineProperties(Text.prototype, {
+    splitText: { enumerable: true },
+    wholeText: { enumerable: true },
+    assignedSlot: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Text", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Text;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Text
+  });
+};
+
+const Impl = require("../nodes/Text-impl.js");
diff --git a/lib/jsdom/living/generated/TextTrackKind.js b/lib/jsdom/living/generated/TextTrackKind.js
new file mode 100644
index 0000000..b3b01c0
--- /dev/null
+++ b/lib/jsdom/living/generated/TextTrackKind.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["subtitles", "captions", "descriptions", "chapters", "metadata"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for TextTrackKind`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/TouchEvent.js b/lib/jsdom/living/generated/TouchEvent.js
new file mode 100644
index 0000000..f110d3e
--- /dev/null
+++ b/lib/jsdom/living/generated/TouchEvent.js
@@ -0,0 +1,194 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertTouchEventInit = require("./TouchEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const UIEvent = require("./UIEvent.js");
+
+const interfaceName = "TouchEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'TouchEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["TouchEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor TouchEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  UIEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.UIEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate TouchEvent before UIEvent");
+  }
+  class TouchEvent extends globalObject.UIEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'TouchEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'TouchEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertTouchEventInit(curArg, { context: "Failed to construct 'TouchEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get touches() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["touches"]);
+    }
+
+    get targetTouches() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["targetTouches"]);
+    }
+
+    get changedTouches() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["changedTouches"]);
+    }
+
+    get altKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["altKey"];
+    }
+
+    get metaKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["metaKey"];
+    }
+
+    get ctrlKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["ctrlKey"];
+    }
+
+    get shiftKey() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["shiftKey"];
+    }
+  }
+  Object.defineProperties(TouchEvent.prototype, {
+    touches: { enumerable: true },
+    targetTouches: { enumerable: true },
+    changedTouches: { enumerable: true },
+    altKey: { enumerable: true },
+    metaKey: { enumerable: true },
+    ctrlKey: { enumerable: true },
+    shiftKey: { enumerable: true },
+    [Symbol.toStringTag]: { value: "TouchEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = TouchEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: TouchEvent
+  });
+};
+
+const Impl = require("../events/TouchEvent-impl.js");
diff --git a/lib/jsdom/living/generated/TouchEventInit.js b/lib/jsdom/living/generated/TouchEventInit.js
new file mode 100644
index 0000000..6b42b0b
--- /dev/null
+++ b/lib/jsdom/living/generated/TouchEventInit.js
@@ -0,0 +1,89 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventModifierInit = require("./EventModifierInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventModifierInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "changedTouches";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new TypeError(context + " has member changedTouches that" + " is not an iterable object.");
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = utils.tryImplForWrapper(nextItem);
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    } else {
+      ret[key] = [];
+    }
+  }
+
+  {
+    const key = "targetTouches";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new TypeError(context + " has member targetTouches that" + " is not an iterable object.");
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = utils.tryImplForWrapper(nextItem);
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    } else {
+      ret[key] = [];
+    }
+  }
+
+  {
+    const key = "touches";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new TypeError(context + " has member touches that" + " is not an iterable object.");
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = utils.tryImplForWrapper(nextItem);
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    } else {
+      ret[key] = [];
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/TreeWalker.js b/lib/jsdom/living/generated/TreeWalker.js
new file mode 100644
index 0000000..f8ad6a9
--- /dev/null
+++ b/lib/jsdom/living/generated/TreeWalker.js
@@ -0,0 +1,220 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertNode = require("./Node.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "TreeWalker";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'TreeWalker'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["TreeWalker"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor TreeWalker is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class TreeWalker {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    parentNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].parentNode());
+    }
+
+    firstChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].firstChild());
+    }
+
+    lastChild() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].lastChild());
+    }
+
+    previousSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].previousSibling());
+    }
+
+    nextSibling() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].nextSibling());
+    }
+
+    previousNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].previousNode());
+    }
+
+    nextNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl].nextNode());
+    }
+
+    get root() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "root", () => {
+        return utils.tryWrapperForImpl(this[impl]["root"]);
+      });
+    }
+
+    get whatToShow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["whatToShow"];
+    }
+
+    get filter() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["filter"]);
+    }
+
+    get currentNode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["currentNode"]);
+    }
+
+    set currentNode(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = convertNode(V, { context: "Failed to set the 'currentNode' property on 'TreeWalker': The provided value" });
+
+      this[impl]["currentNode"] = V;
+    }
+  }
+  Object.defineProperties(TreeWalker.prototype, {
+    parentNode: { enumerable: true },
+    firstChild: { enumerable: true },
+    lastChild: { enumerable: true },
+    previousSibling: { enumerable: true },
+    nextSibling: { enumerable: true },
+    previousNode: { enumerable: true },
+    nextNode: { enumerable: true },
+    root: { enumerable: true },
+    whatToShow: { enumerable: true },
+    filter: { enumerable: true },
+    currentNode: { enumerable: true },
+    [Symbol.toStringTag]: { value: "TreeWalker", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = TreeWalker;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: TreeWalker
+  });
+};
+
+const Impl = require("../traversal/TreeWalker-impl.js");
diff --git a/lib/jsdom/living/generated/UIEvent.js b/lib/jsdom/living/generated/UIEvent.js
new file mode 100644
index 0000000..9b2dddc
--- /dev/null
+++ b/lib/jsdom/living/generated/UIEvent.js
@@ -0,0 +1,228 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertUIEventInit = require("./UIEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "UIEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'UIEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["UIEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor UIEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Event._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Event === undefined) {
+    throw new Error("Internal error: attempting to evaluate UIEvent before Event");
+  }
+  class UIEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'UIEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'UIEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertUIEventInit(curArg, { context: "Failed to construct 'UIEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    initUIEvent(typeArg) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'initUIEvent' on 'UIEvent': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initUIEvent' on 'UIEvent': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initUIEvent' on 'UIEvent': parameter 2"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'initUIEvent' on 'UIEvent': parameter 3"
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            curArg = utils.tryImplForWrapper(curArg);
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[4];
+        if (curArg !== undefined) {
+          curArg = conversions["long"](curArg, {
+            context: "Failed to execute 'initUIEvent' on 'UIEvent': parameter 5"
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return this[impl].initUIEvent(...args);
+    }
+
+    get view() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["view"]);
+    }
+
+    get detail() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["detail"];
+    }
+
+    get which() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["which"];
+    }
+  }
+  Object.defineProperties(UIEvent.prototype, {
+    initUIEvent: { enumerable: true },
+    view: { enumerable: true },
+    detail: { enumerable: true },
+    which: { enumerable: true },
+    [Symbol.toStringTag]: { value: "UIEvent", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = UIEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: UIEvent
+  });
+};
+
+const Impl = require("../events/UIEvent-impl.js");
diff --git a/lib/jsdom/living/generated/UIEventInit.js b/lib/jsdom/living/generated/UIEventInit.js
new file mode 100644
index 0000000..347cba9
--- /dev/null
+++ b/lib/jsdom/living/generated/UIEventInit.js
@@ -0,0 +1,59 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  EventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "detail";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member detail that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "view";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (value === null || value === undefined) {
+        value = null;
+      } else {
+        value = utils.tryImplForWrapper(value);
+      }
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+
+  {
+    const key = "which";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member which that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/ValidityState.js b/lib/jsdom/living/generated/ValidityState.js
new file mode 100644
index 0000000..669e262
--- /dev/null
+++ b/lib/jsdom/living/generated/ValidityState.js
@@ -0,0 +1,207 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "ValidityState";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'ValidityState'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["ValidityState"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor ValidityState is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class ValidityState {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get valueMissing() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["valueMissing"];
+    }
+
+    get typeMismatch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["typeMismatch"];
+    }
+
+    get patternMismatch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["patternMismatch"];
+    }
+
+    get tooLong() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["tooLong"];
+    }
+
+    get tooShort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["tooShort"];
+    }
+
+    get rangeUnderflow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["rangeUnderflow"];
+    }
+
+    get rangeOverflow() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["rangeOverflow"];
+    }
+
+    get stepMismatch() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["stepMismatch"];
+    }
+
+    get badInput() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["badInput"];
+    }
+
+    get customError() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["customError"];
+    }
+
+    get valid() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["valid"];
+    }
+  }
+  Object.defineProperties(ValidityState.prototype, {
+    valueMissing: { enumerable: true },
+    typeMismatch: { enumerable: true },
+    patternMismatch: { enumerable: true },
+    tooLong: { enumerable: true },
+    tooShort: { enumerable: true },
+    rangeUnderflow: { enumerable: true },
+    rangeOverflow: { enumerable: true },
+    stepMismatch: { enumerable: true },
+    badInput: { enumerable: true },
+    customError: { enumerable: true },
+    valid: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ValidityState", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = ValidityState;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ValidityState
+  });
+};
+
+const Impl = require("../constraint-validation/ValidityState-impl.js");
diff --git a/lib/jsdom/living/generated/VisibilityState.js b/lib/jsdom/living/generated/VisibilityState.js
new file mode 100644
index 0000000..3a68b07
--- /dev/null
+++ b/lib/jsdom/living/generated/VisibilityState.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["hidden", "visible", "prerender"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for VisibilityState`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/WebSocket.js b/lib/jsdom/living/generated/WebSocket.js
new file mode 100644
index 0000000..3a7b5e2
--- /dev/null
+++ b/lib/jsdom/living/generated/WebSocket.js
@@ -0,0 +1,392 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isBlob = require("./Blob.js").is;
+const convertBlob = require("./Blob.js").convert;
+const BinaryType = require("./BinaryType.js");
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "WebSocket";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'WebSocket'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["WebSocket"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor WebSocket is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  EventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.EventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate WebSocket before EventTarget");
+  }
+  class WebSocket extends globalObject.EventTarget {
+    constructor(url) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'WebSocket': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["USVString"](curArg, { context: "Failed to construct 'WebSocket': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          if (utils.isObject(curArg)) {
+            if (curArg[Symbol.iterator] !== undefined) {
+              if (!utils.isObject(curArg)) {
+                throw new TypeError(
+                  "Failed to construct 'WebSocket': parameter 2" + " sequence" + " is not an iterable object."
+                );
+              } else {
+                const V = [];
+                const tmp = curArg;
+                for (let nextItem of tmp) {
+                  nextItem = conversions["DOMString"](nextItem, {
+                    context: "Failed to construct 'WebSocket': parameter 2" + " sequence" + "'s element"
+                  });
+
+                  V.push(nextItem);
+                }
+                curArg = V;
+              }
+            } else {
+            }
+          } else {
+            curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'WebSocket': parameter 2" });
+          }
+        } else {
+          curArg = [];
+        }
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    close() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned short"](curArg, {
+            context: "Failed to execute 'close' on 'WebSocket': parameter 1",
+            clamp: true
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["USVString"](curArg, {
+            context: "Failed to execute 'close' on 'WebSocket': parameter 2"
+          });
+        }
+        args.push(curArg);
+      }
+      return this[impl].close(...args);
+    }
+
+    send(data) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'send' on 'WebSocket': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (isBlob(curArg)) {
+          {
+            let curArg = arguments[0];
+            curArg = convertBlob(curArg, { context: "Failed to execute 'send' on 'WebSocket': parameter 1" });
+            args.push(curArg);
+          }
+        } else if (utils.isArrayBuffer(curArg)) {
+          {
+            let curArg = arguments[0];
+            curArg = conversions["ArrayBuffer"](curArg, {
+              context: "Failed to execute 'send' on 'WebSocket': parameter 1"
+            });
+            args.push(curArg);
+          }
+        } else if (ArrayBuffer.isView(curArg)) {
+          {
+            let curArg = arguments[0];
+            if (ArrayBuffer.isView(curArg)) {
+            } else {
+              throw new TypeError(
+                "Failed to execute 'send' on 'WebSocket': parameter 1" + " is not of any supported type."
+              );
+            }
+            args.push(curArg);
+          }
+        } else {
+          {
+            let curArg = arguments[0];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'send' on 'WebSocket': parameter 1"
+            });
+            args.push(curArg);
+          }
+        }
+      }
+      return this[impl].send(...args);
+    }
+
+    get url() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["url"];
+    }
+
+    get readyState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["readyState"];
+    }
+
+    get bufferedAmount() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["bufferedAmount"];
+    }
+
+    get onopen() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onopen"]);
+    }
+
+    set onopen(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onopen"] = V;
+    }
+
+    get onerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onerror"]);
+    }
+
+    set onerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onerror"] = V;
+    }
+
+    get onclose() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onclose"]);
+    }
+
+    set onclose(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onclose"] = V;
+    }
+
+    get extensions() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["extensions"];
+    }
+
+    get protocol() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["protocol"];
+    }
+
+    get onmessage() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onmessage"]);
+    }
+
+    set onmessage(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onmessage"] = V;
+    }
+
+    get binaryType() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["binaryType"]);
+    }
+
+    set binaryType(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = `${V}`;
+      if (!BinaryType.enumerationValues.has(V)) {
+        return;
+      }
+
+      this[impl]["binaryType"] = V;
+    }
+  }
+  Object.defineProperties(WebSocket.prototype, {
+    close: { enumerable: true },
+    send: { enumerable: true },
+    url: { enumerable: true },
+    readyState: { enumerable: true },
+    bufferedAmount: { enumerable: true },
+    onopen: { enumerable: true },
+    onerror: { enumerable: true },
+    onclose: { enumerable: true },
+    extensions: { enumerable: true },
+    protocol: { enumerable: true },
+    onmessage: { enumerable: true },
+    binaryType: { enumerable: true },
+    [Symbol.toStringTag]: { value: "WebSocket", configurable: true },
+    CONNECTING: { value: 0, enumerable: true },
+    OPEN: { value: 1, enumerable: true },
+    CLOSING: { value: 2, enumerable: true },
+    CLOSED: { value: 3, enumerable: true }
+  });
+  Object.defineProperties(WebSocket, {
+    CONNECTING: { value: 0, enumerable: true },
+    OPEN: { value: 1, enumerable: true },
+    CLOSING: { value: 2, enumerable: true },
+    CLOSED: { value: 3, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = WebSocket;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: WebSocket
+  });
+};
+
+const Impl = require("../websockets/WebSocket-impl.js");
diff --git a/lib/jsdom/living/generated/WheelEvent.js b/lib/jsdom/living/generated/WheelEvent.js
new file mode 100644
index 0000000..f1fcf30
--- /dev/null
+++ b/lib/jsdom/living/generated/WheelEvent.js
@@ -0,0 +1,175 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertWheelEventInit = require("./WheelEventInit.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const MouseEvent = require("./MouseEvent.js");
+
+const interfaceName = "WheelEvent";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'WheelEvent'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["WheelEvent"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor WheelEvent is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  MouseEvent._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.MouseEvent === undefined) {
+    throw new Error("Internal error: attempting to evaluate WheelEvent before MouseEvent");
+  }
+  class WheelEvent extends globalObject.MouseEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to construct 'WheelEvent': 1 argument required, but only " + arguments.length + " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'WheelEvent': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = convertWheelEventInit(curArg, { context: "Failed to construct 'WheelEvent': parameter 2" });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get deltaX() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["deltaX"];
+    }
+
+    get deltaY() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["deltaY"];
+    }
+
+    get deltaZ() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["deltaZ"];
+    }
+
+    get deltaMode() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["deltaMode"];
+    }
+  }
+  Object.defineProperties(WheelEvent.prototype, {
+    deltaX: { enumerable: true },
+    deltaY: { enumerable: true },
+    deltaZ: { enumerable: true },
+    deltaMode: { enumerable: true },
+    [Symbol.toStringTag]: { value: "WheelEvent", configurable: true },
+    DOM_DELTA_PIXEL: { value: 0x00, enumerable: true },
+    DOM_DELTA_LINE: { value: 0x01, enumerable: true },
+    DOM_DELTA_PAGE: { value: 0x02, enumerable: true }
+  });
+  Object.defineProperties(WheelEvent, {
+    DOM_DELTA_PIXEL: { value: 0x00, enumerable: true },
+    DOM_DELTA_LINE: { value: 0x01, enumerable: true },
+    DOM_DELTA_PAGE: { value: 0x02, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = WheelEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: WheelEvent
+  });
+};
+
+const Impl = require("../events/WheelEvent-impl.js");
diff --git a/lib/jsdom/living/generated/WheelEventInit.js b/lib/jsdom/living/generated/WheelEventInit.js
new file mode 100644
index 0000000..6b9f817
--- /dev/null
+++ b/lib/jsdom/living/generated/WheelEventInit.js
@@ -0,0 +1,68 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const MouseEventInit = require("./MouseEventInit.js");
+
+exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
+  MouseEventInit.convertInherit(obj, ret, { context });
+
+  {
+    const key = "deltaMode";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, { context: context + " has member deltaMode that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "deltaX";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, { context: context + " has member deltaX that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0.0;
+    }
+  }
+
+  {
+    const key = "deltaY";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, { context: context + " has member deltaY that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0.0;
+    }
+  }
+
+  {
+    const key = "deltaZ";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, { context: context + " has member deltaZ that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0.0;
+    }
+  }
+};
+
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  module.exports.convertInherit(obj, ret, { context });
+  return ret;
+};
diff --git a/lib/jsdom/living/generated/XMLDocument.js b/lib/jsdom/living/generated/XMLDocument.js
new file mode 100644
index 0000000..cbf0f8f
--- /dev/null
+++ b/lib/jsdom/living/generated/XMLDocument.js
@@ -0,0 +1,114 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const Document = require("./Document.js");
+
+const interfaceName = "XMLDocument";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'XMLDocument'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["XMLDocument"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor XMLDocument is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  Document._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.Document === undefined) {
+    throw new Error("Internal error: attempting to evaluate XMLDocument before Document");
+  }
+  class XMLDocument extends globalObject.Document {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(XMLDocument.prototype, {
+    [Symbol.toStringTag]: { value: "XMLDocument", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = XMLDocument;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: XMLDocument
+  });
+};
+
+const Impl = require("../nodes/XMLDocument-impl.js");
diff --git a/lib/jsdom/living/generated/XMLHttpRequest.js b/lib/jsdom/living/generated/XMLHttpRequest.js
new file mode 100644
index 0000000..e0ff063
--- /dev/null
+++ b/lib/jsdom/living/generated/XMLHttpRequest.js
@@ -0,0 +1,562 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const isDocument = require("./Document.js").is;
+const isBlob = require("./Blob.js").is;
+const isFormData = require("./FormData.js").is;
+const XMLHttpRequestResponseType = require("./XMLHttpRequestResponseType.js");
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const XMLHttpRequestEventTarget = require("./XMLHttpRequestEventTarget.js");
+
+const interfaceName = "XMLHttpRequest";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'XMLHttpRequest'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["XMLHttpRequest"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor XMLHttpRequest is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  XMLHttpRequestEventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.XMLHttpRequestEventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate XMLHttpRequest before XMLHttpRequestEventTarget");
+  }
+  class XMLHttpRequest extends globalObject.XMLHttpRequestEventTarget {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    open(method, url) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'open' on 'XMLHttpRequest': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      switch (arguments.length) {
+        case 2:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["ByteString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 2"
+            });
+            args.push(curArg);
+          }
+          break;
+        case 3:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["ByteString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 3"
+            });
+            args.push(curArg);
+          }
+          break;
+        case 4:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["ByteString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 3"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[3];
+            if (curArg !== undefined) {
+              if (curArg === null || curArg === undefined) {
+                curArg = null;
+              } else {
+                curArg = conversions["USVString"](curArg, {
+                  context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 4"
+                });
+              }
+            } else {
+              curArg = null;
+            }
+            args.push(curArg);
+          }
+          break;
+        default:
+          {
+            let curArg = arguments[0];
+            curArg = conversions["ByteString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 1"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions["USVString"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 2"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[2];
+            curArg = conversions["boolean"](curArg, {
+              context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 3"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[3];
+            if (curArg !== undefined) {
+              if (curArg === null || curArg === undefined) {
+                curArg = null;
+              } else {
+                curArg = conversions["USVString"](curArg, {
+                  context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 4"
+                });
+              }
+            } else {
+              curArg = null;
+            }
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[4];
+            if (curArg !== undefined) {
+              if (curArg === null || curArg === undefined) {
+                curArg = null;
+              } else {
+                curArg = conversions["USVString"](curArg, {
+                  context: "Failed to execute 'open' on 'XMLHttpRequest': parameter 5"
+                });
+              }
+            } else {
+              curArg = null;
+            }
+            args.push(curArg);
+          }
+      }
+      return this[impl].open(...args);
+    }
+
+    setRequestHeader(name, value) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(
+          "Failed to execute 'setRequestHeader' on 'XMLHttpRequest': 2 arguments required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, {
+          context: "Failed to execute 'setRequestHeader' on 'XMLHttpRequest': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["ByteString"](curArg, {
+          context: "Failed to execute 'setRequestHeader' on 'XMLHttpRequest': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return this[impl].setRequestHeader(...args);
+    }
+
+    send() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          if (curArg === null || curArg === undefined) {
+            curArg = null;
+          } else {
+            if (isDocument(curArg) || isBlob(curArg) || isFormData(curArg)) {
+              curArg = utils.implForWrapper(curArg);
+            } else if (utils.isArrayBuffer(curArg)) {
+            } else if (ArrayBuffer.isView(curArg)) {
+            } else {
+              curArg = conversions["USVString"](curArg, {
+                context: "Failed to execute 'send' on 'XMLHttpRequest': parameter 1"
+              });
+            }
+          }
+        } else {
+          curArg = null;
+        }
+        args.push(curArg);
+      }
+      return this[impl].send(...args);
+    }
+
+    abort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].abort();
+    }
+
+    getResponseHeader(name) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'getResponseHeader' on 'XMLHttpRequest': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["ByteString"](curArg, {
+          context: "Failed to execute 'getResponseHeader' on 'XMLHttpRequest': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].getResponseHeader(...args);
+    }
+
+    getAllResponseHeaders() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl].getAllResponseHeaders();
+    }
+
+    overrideMimeType(mime) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'overrideMimeType' on 'XMLHttpRequest': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'overrideMimeType' on 'XMLHttpRequest': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].overrideMimeType(...args);
+    }
+
+    get onreadystatechange() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onreadystatechange"]);
+    }
+
+    set onreadystatechange(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onreadystatechange"] = V;
+    }
+
+    get readyState() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["readyState"];
+    }
+
+    get timeout() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["timeout"];
+    }
+
+    set timeout(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["unsigned long"](V, {
+        context: "Failed to set the 'timeout' property on 'XMLHttpRequest': The provided value"
+      });
+
+      this[impl]["timeout"] = V;
+    }
+
+    get withCredentials() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["withCredentials"];
+    }
+
+    set withCredentials(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = conversions["boolean"](V, {
+        context: "Failed to set the 'withCredentials' property on 'XMLHttpRequest': The provided value"
+      });
+
+      this[impl]["withCredentials"] = V;
+    }
+
+    get upload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.getSameObject(this, "upload", () => {
+        return utils.tryWrapperForImpl(this[impl]["upload"]);
+      });
+    }
+
+    get responseURL() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["responseURL"];
+    }
+
+    get status() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["status"];
+    }
+
+    get statusText() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["statusText"];
+    }
+
+    get responseType() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["responseType"]);
+    }
+
+    set responseType(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = `${V}`;
+      if (!XMLHttpRequestResponseType.enumerationValues.has(V)) {
+        return;
+      }
+
+      this[impl]["responseType"] = V;
+    }
+
+    get response() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["response"];
+    }
+
+    get responseText() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return this[impl]["responseText"];
+    }
+
+    get responseXML() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["responseXML"]);
+    }
+  }
+  Object.defineProperties(XMLHttpRequest.prototype, {
+    open: { enumerable: true },
+    setRequestHeader: { enumerable: true },
+    send: { enumerable: true },
+    abort: { enumerable: true },
+    getResponseHeader: { enumerable: true },
+    getAllResponseHeaders: { enumerable: true },
+    overrideMimeType: { enumerable: true },
+    onreadystatechange: { enumerable: true },
+    readyState: { enumerable: true },
+    timeout: { enumerable: true },
+    withCredentials: { enumerable: true },
+    upload: { enumerable: true },
+    responseURL: { enumerable: true },
+    status: { enumerable: true },
+    statusText: { enumerable: true },
+    responseType: { enumerable: true },
+    response: { enumerable: true },
+    responseText: { enumerable: true },
+    responseXML: { enumerable: true },
+    [Symbol.toStringTag]: { value: "XMLHttpRequest", configurable: true },
+    UNSENT: { value: 0, enumerable: true },
+    OPENED: { value: 1, enumerable: true },
+    HEADERS_RECEIVED: { value: 2, enumerable: true },
+    LOADING: { value: 3, enumerable: true },
+    DONE: { value: 4, enumerable: true }
+  });
+  Object.defineProperties(XMLHttpRequest, {
+    UNSENT: { value: 0, enumerable: true },
+    OPENED: { value: 1, enumerable: true },
+    HEADERS_RECEIVED: { value: 2, enumerable: true },
+    LOADING: { value: 3, enumerable: true },
+    DONE: { value: 4, enumerable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = XMLHttpRequest;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: XMLHttpRequest
+  });
+};
+
+const Impl = require("../xhr/XMLHttpRequest-impl.js");
diff --git a/lib/jsdom/living/generated/XMLHttpRequestEventTarget.js b/lib/jsdom/living/generated/XMLHttpRequestEventTarget.js
new file mode 100644
index 0000000..75da5fb
--- /dev/null
+++ b/lib/jsdom/living/generated/XMLHttpRequestEventTarget.js
@@ -0,0 +1,249 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "XMLHttpRequestEventTarget";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'XMLHttpRequestEventTarget'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["XMLHttpRequestEventTarget"];
+  if (ctor === undefined) {
+    throw new Error(
+      "Internal error: constructor XMLHttpRequestEventTarget is not installed on the passed global object"
+    );
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  EventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.EventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate XMLHttpRequestEventTarget before EventTarget");
+  }
+  class XMLHttpRequestEventTarget extends globalObject.EventTarget {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+
+    get onloadstart() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadstart"]);
+    }
+
+    set onloadstart(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadstart"] = V;
+    }
+
+    get onprogress() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onprogress"]);
+    }
+
+    set onprogress(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onprogress"] = V;
+    }
+
+    get onabort() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onabort"]);
+    }
+
+    set onabort(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onabort"] = V;
+    }
+
+    get onerror() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onerror"]);
+    }
+
+    set onerror(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onerror"] = V;
+    }
+
+    get onload() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onload"]);
+    }
+
+    set onload(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onload"] = V;
+    }
+
+    get ontimeout() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["ontimeout"]);
+    }
+
+    set ontimeout(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["ontimeout"] = V;
+    }
+
+    get onloadend() {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      return utils.tryWrapperForImpl(this[impl]["onloadend"]);
+    }
+
+    set onloadend(V) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      V = utils.tryImplForWrapper(V);
+
+      this[impl]["onloadend"] = V;
+    }
+  }
+  Object.defineProperties(XMLHttpRequestEventTarget.prototype, {
+    onloadstart: { enumerable: true },
+    onprogress: { enumerable: true },
+    onabort: { enumerable: true },
+    onerror: { enumerable: true },
+    onload: { enumerable: true },
+    ontimeout: { enumerable: true },
+    onloadend: { enumerable: true },
+    [Symbol.toStringTag]: { value: "XMLHttpRequestEventTarget", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = XMLHttpRequestEventTarget;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: XMLHttpRequestEventTarget
+  });
+};
+
+const Impl = require("../xhr/XMLHttpRequestEventTarget-impl.js");
diff --git a/lib/jsdom/living/generated/XMLHttpRequestResponseType.js b/lib/jsdom/living/generated/XMLHttpRequestResponseType.js
new file mode 100644
index 0000000..98e92bb
--- /dev/null
+++ b/lib/jsdom/living/generated/XMLHttpRequestResponseType.js
@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["", "arraybuffer", "blob", "document", "json", "text"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = function convert(value, { context = "The provided value" } = {}) {
+  const string = `${value}`;
+  if (!enumerationValues.has(value)) {
+    throw new TypeError(`${context} '${value}' is not a valid enumeration value for XMLHttpRequestResponseType`);
+  }
+  return string;
+};
diff --git a/lib/jsdom/living/generated/XMLHttpRequestUpload.js b/lib/jsdom/living/generated/XMLHttpRequestUpload.js
new file mode 100644
index 0000000..1df3d06
--- /dev/null
+++ b/lib/jsdom/living/generated/XMLHttpRequestUpload.js
@@ -0,0 +1,114 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+const XMLHttpRequestEventTarget = require("./XMLHttpRequestEventTarget.js");
+
+const interfaceName = "XMLHttpRequestUpload";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'XMLHttpRequestUpload'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["XMLHttpRequestUpload"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor XMLHttpRequestUpload is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {
+  XMLHttpRequestEventTarget._internalSetup(obj);
+};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  if (globalObject.XMLHttpRequestEventTarget === undefined) {
+    throw new Error("Internal error: attempting to evaluate XMLHttpRequestUpload before XMLHttpRequestEventTarget");
+  }
+  class XMLHttpRequestUpload extends globalObject.XMLHttpRequestEventTarget {
+    constructor() {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(XMLHttpRequestUpload.prototype, {
+    [Symbol.toStringTag]: { value: "XMLHttpRequestUpload", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = XMLHttpRequestUpload;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: XMLHttpRequestUpload
+  });
+};
+
+const Impl = require("../xhr/XMLHttpRequestUpload-impl.js");
diff --git a/lib/jsdom/living/generated/XMLSerializer.js b/lib/jsdom/living/generated/XMLSerializer.js
new file mode 100644
index 0000000..5b8feb2
--- /dev/null
+++ b/lib/jsdom/living/generated/XMLSerializer.js
@@ -0,0 +1,133 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const convertNode = require("./Node.js").convert;
+const impl = utils.implSymbol;
+const ctorRegistry = utils.ctorRegistrySymbol;
+
+const interfaceName = "XMLSerializer";
+
+/**
+ * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+ * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+ * implementing this mixin interface.
+ */
+exports._mixedIntoPredicates = [];
+exports.is = function is(obj) {
+  if (obj) {
+    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+      return true;
+    }
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(obj)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.isImpl = function isImpl(obj) {
+  if (obj) {
+    if (obj instanceof Impl.implementation) {
+      return true;
+    }
+
+    const wrapper = utils.wrapperForImpl(obj);
+    for (const isMixedInto of exports._mixedIntoPredicates) {
+      if (isMixedInto(wrapper)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+  if (exports.is(obj)) {
+    return utils.implForWrapper(obj);
+  }
+  throw new TypeError(`${context} is not of type 'XMLSerializer'.`);
+};
+
+exports.create = function create(globalObject, constructorArgs, privateData) {
+  if (globalObject[ctorRegistry] === undefined) {
+    throw new Error("Internal error: invalid global object");
+  }
+
+  const ctor = globalObject[ctorRegistry]["XMLSerializer"];
+  if (ctor === undefined) {
+    throw new Error("Internal error: constructor XMLSerializer is not installed on the passed global object");
+  }
+
+  let obj = Object.create(ctor.prototype);
+  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
+  return obj;
+};
+exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+  const obj = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(obj);
+};
+exports._internalSetup = function _internalSetup(obj) {};
+exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+  privateData.wrapper = obj;
+
+  exports._internalSetup(obj);
+  Object.defineProperty(obj, impl, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  obj[impl][utils.wrapperSymbol] = obj;
+  if (Impl.init) {
+    Impl.init(obj[impl], privateData);
+  }
+  return obj;
+};
+
+exports.install = function install(globalObject) {
+  class XMLSerializer {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    serializeToString(root) {
+      if (!this || !exports.is(this)) {
+        throw new TypeError("Illegal invocation");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(
+          "Failed to execute 'serializeToString' on 'XMLSerializer': 1 argument required, but only " +
+            arguments.length +
+            " present."
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = convertNode(curArg, {
+          context: "Failed to execute 'serializeToString' on 'XMLSerializer': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return this[impl].serializeToString(...args);
+    }
+  }
+  Object.defineProperties(XMLSerializer.prototype, {
+    serializeToString: { enumerable: true },
+    [Symbol.toStringTag]: { value: "XMLSerializer", configurable: true }
+  });
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = XMLSerializer;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: XMLSerializer
+  });
+};
+
+const Impl = require("../domparsing/XMLSerializer-impl.js");
diff --git a/lib/jsdom/living/generated/utils.js b/lib/jsdom/living/generated/utils.js
new file mode 100644
index 0000000..c020d0b
--- /dev/null
+++ b/lib/jsdom/living/generated/utils.js
@@ -0,0 +1,115 @@
+"use strict";
+
+// Returns "Type(value) is Object" in ES terminology.
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+const wrapperSymbol = Symbol("wrapper");
+const implSymbol = Symbol("impl");
+const sameObjectCaches = Symbol("SameObject caches");
+const ctorRegistrySymbol = Symbol.for("[webidl2js]  constructor registry");
+
+function getSameObject(wrapper, prop, creator) {
+  if (!wrapper[sameObjectCaches]) {
+    wrapper[sameObjectCaches] = Object.create(null);
+  }
+
+  if (prop in wrapper[sameObjectCaches]) {
+    return wrapper[sameObjectCaches][prop];
+  }
+
+  wrapper[sameObjectCaches][prop] = creator();
+  return wrapper[sameObjectCaches][prop];
+}
+
+function wrapperForImpl(impl) {
+  return impl ? impl[wrapperSymbol] : null;
+}
+
+function implForWrapper(wrapper) {
+  return wrapper ? wrapper[implSymbol] : null;
+}
+
+function tryWrapperForImpl(impl) {
+  const wrapper = wrapperForImpl(impl);
+  return wrapper ? wrapper : impl;
+}
+
+function tryImplForWrapper(wrapper) {
+  const impl = implForWrapper(wrapper);
+  return impl ? impl : wrapper;
+}
+
+const iterInternalSymbol = Symbol("internal");
+const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+
+function isArrayIndexPropName(P) {
+  if (typeof P !== "string") {
+    return false;
+  }
+  const i = P >>> 0;
+  if (i === Math.pow(2, 32) - 1) {
+    return false;
+  }
+  const s = `${i}`;
+  if (P !== s) {
+    return false;
+  }
+  return true;
+}
+
+const byteLengthGetter =
+    Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+function isArrayBuffer(value) {
+  try {
+    byteLengthGetter.call(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+const supportsPropertyIndex = Symbol("supports property index");
+const supportedPropertyIndices = Symbol("supported property indices");
+const supportsPropertyName = Symbol("supports property name");
+const supportedPropertyNames = Symbol("supported property names");
+const indexedGet = Symbol("indexed property get");
+const indexedSetNew = Symbol("indexed property set new");
+const indexedSetExisting = Symbol("indexed property set existing");
+const namedGet = Symbol("named property get");
+const namedSetNew = Symbol("named property set new");
+const namedSetExisting = Symbol("named property set existing");
+const namedDelete = Symbol("named property delete");
+
+module.exports = exports = {
+  isObject,
+  hasOwn,
+  wrapperSymbol,
+  implSymbol,
+  getSameObject,
+  ctorRegistrySymbol,
+  wrapperForImpl,
+  implForWrapper,
+  tryWrapperForImpl,
+  tryImplForWrapper,
+  iterInternalSymbol,
+  IteratorPrototype,
+  isArrayBuffer,
+  isArrayIndexPropName,
+  supportsPropertyIndex,
+  supportedPropertyIndices,
+  supportsPropertyName,
+  supportedPropertyNames,
+  indexedGet,
+  indexedSetNew,
+  indexedSetExisting,
+  namedGet,
+  namedSetNew,
+  namedSetExisting,
+  namedDelete
+};
diff --git a/lib/jsdom/living/helpers/binary-data.js b/lib/jsdom/living/helpers/binary-data.js
new file mode 100644
index 0000000..dc5909c
--- /dev/null
+++ b/lib/jsdom/living/helpers/binary-data.js
@@ -0,0 +1,9 @@
+"use strict";
+
+// See https://github.com/jsdom/jsdom/pull/2743#issuecomment-562991955 for background.
+exports.copyToArrayBufferInNewRealm = (nodejsBuffer, newRealm) => {
+  const newAB = new newRealm.ArrayBuffer(nodejsBuffer.byteLength);
+  const view = new Uint8Array(newAB);
+  view.set(nodejsBuffer);
+  return newAB;
+};
diff --git a/lib/jsdom/living/helpers/create-element.js b/lib/jsdom/living/helpers/create-element.js
new file mode 100644
index 0000000..6bd69ad
--- /dev/null
+++ b/lib/jsdom/living/helpers/create-element.js
@@ -0,0 +1,320 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const interfaces = require("../interfaces");
+
+const { implForWrapper } = require("../generated/utils");
+
+const { HTML_NS, SVG_NS } = require("./namespaces");
+const { domSymbolTree } = require("./internal-constants");
+const { validateAndExtract } = require("./validate-names");
+const reportException = require("./runtime-script-errors");
+const {
+  isValidCustomElementName, upgradeElement, lookupCEDefinition, enqueueCEUpgradeReaction
+} = require("./custom-elements");
+
+const INTERFACE_TAG_MAPPING = {
+  // https://html.spec.whatwg.org/multipage/dom.html#elements-in-the-dom%3Aelement-interface
+  // https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  [HTML_NS]: {
+    HTMLElement: [
+      "abbr", "address", "article", "aside", "b", "bdi", "bdo", "cite", "code", "dd", "dfn", "dt", "em", "figcaption",
+      "figure", "footer", "header", "hgroup", "i", "kbd", "main", "mark", "nav", "noscript", "rp", "rt", "ruby", "s",
+      "samp", "section", "small", "strong", "sub", "summary", "sup", "u", "var", "wbr"
+    ],
+    HTMLAnchorElement: ["a"],
+    HTMLAreaElement: ["area"],
+    HTMLAudioElement: ["audio"],
+    HTMLBaseElement: ["base"],
+    HTMLBodyElement: ["body"],
+    HTMLBRElement: ["br"],
+    HTMLButtonElement: ["button"],
+    HTMLCanvasElement: ["canvas"],
+    HTMLDataElement: ["data"],
+    HTMLDataListElement: ["datalist"],
+    HTMLDetailsElement: ["details"],
+    HTMLDialogElement: ["dialog"],
+    HTMLDirectoryElement: ["dir"],
+    HTMLDivElement: ["div"],
+    HTMLDListElement: ["dl"],
+    HTMLEmbedElement: ["embed"],
+    HTMLFieldSetElement: ["fieldset"],
+    HTMLFontElement: ["font"],
+    HTMLFormElement: ["form"],
+    HTMLFrameElement: ["frame"],
+    HTMLFrameSetElement: ["frameset"],
+    HTMLHeadingElement: ["h1", "h2", "h3", "h4", "h5", "h6"],
+    HTMLHeadElement: ["head"],
+    HTMLHRElement: ["hr"],
+    HTMLHtmlElement: ["html"],
+    HTMLIFrameElement: ["iframe"],
+    HTMLImageElement: ["img"],
+    HTMLInputElement: ["input"],
+    HTMLLabelElement: ["label"],
+    HTMLLegendElement: ["legend"],
+    HTMLLIElement: ["li"],
+    HTMLLinkElement: ["link"],
+    HTMLMapElement: ["map"],
+    HTMLMarqueeElement: ["marquee"],
+    HTMLMediaElement: [],
+    HTMLMenuElement: ["menu"],
+    HTMLMetaElement: ["meta"],
+    HTMLMeterElement: ["meter"],
+    HTMLModElement: ["del", "ins"],
+    HTMLObjectElement: ["object"],
+    HTMLOListElement: ["ol"],
+    HTMLOptGroupElement: ["optgroup"],
+    HTMLOptionElement: ["option"],
+    HTMLOutputElement: ["output"],
+    HTMLParagraphElement: ["p"],
+    HTMLParamElement: ["param"],
+    HTMLPictureElement: ["picture"],
+    HTMLPreElement: ["listing", "pre", "xmp"],
+    HTMLProgressElement: ["progress"],
+    HTMLQuoteElement: ["blockquote", "q"],
+    HTMLScriptElement: ["script"],
+    HTMLSelectElement: ["select"],
+    HTMLSlotElement: ["slot"],
+    HTMLSourceElement: ["source"],
+    HTMLSpanElement: ["span"],
+    HTMLStyleElement: ["style"],
+    HTMLTableCaptionElement: ["caption"],
+    HTMLTableCellElement: ["th", "td"],
+    HTMLTableColElement: ["col", "colgroup"],
+    HTMLTableElement: ["table"],
+    HTMLTimeElement: ["time"],
+    HTMLTitleElement: ["title"],
+    HTMLTableRowElement: ["tr"],
+    HTMLTableSectionElement: ["thead", "tbody", "tfoot"],
+    HTMLTemplateElement: ["template"],
+    HTMLTextAreaElement: ["textarea"],
+    HTMLTrackElement: ["track"],
+    HTMLUListElement: ["ul"],
+    HTMLUnknownElement: [],
+    HTMLVideoElement: ["video"]
+  },
+  [SVG_NS]: {
+    SVGElement: [],
+    SVGGraphicsElement: [],
+    SVGSVGElement: ["svg"],
+    SVGTitleElement: ["title"]
+  }
+};
+
+const TAG_INTERFACE_LOOKUP = {};
+
+for (const namespace of [HTML_NS, SVG_NS]) {
+  TAG_INTERFACE_LOOKUP[namespace] = {};
+
+  const interfaceNames = Object.keys(INTERFACE_TAG_MAPPING[namespace]);
+  for (const interfaceName of interfaceNames) {
+    const tagNames = INTERFACE_TAG_MAPPING[namespace][interfaceName];
+
+    for (const tagName of tagNames) {
+      TAG_INTERFACE_LOOKUP[namespace][tagName] = interfaceName;
+    }
+  }
+}
+
+const UNKNOWN_HTML_ELEMENTS_NAMES = ["applet", "bgsound", "blink", "isindex", "keygen", "multicol", "nextid", "spacer"];
+const HTML_ELEMENTS_NAMES = [
+  "acronym", "basefont", "big", "center", "nobr", "noembed", "noframes", "plaintext", "rb", "rtc",
+  "strike", "tt"
+];
+
+// https://html.spec.whatwg.org/multipage/dom.html#elements-in-the-dom:element-interface
+function getHTMLElementInterface(name) {
+  if (UNKNOWN_HTML_ELEMENTS_NAMES.includes(name)) {
+    return interfaces.getInterfaceWrapper("HTMLUnknownElement");
+  }
+
+  if (HTML_ELEMENTS_NAMES.includes(name)) {
+    return interfaces.getInterfaceWrapper("HTMLElement");
+  }
+
+  const specDefinedInterface = TAG_INTERFACE_LOOKUP[HTML_NS][name];
+  if (specDefinedInterface !== undefined) {
+    return interfaces.getInterfaceWrapper(specDefinedInterface);
+  }
+
+  if (isValidCustomElementName(name)) {
+    return interfaces.getInterfaceWrapper("HTMLElement");
+  }
+
+  return interfaces.getInterfaceWrapper("HTMLUnknownElement");
+}
+
+// https://svgwg.org/svg2-draft/types.html#ElementsInTheSVGDOM
+function getSVGInterface(name) {
+  const specDefinedInterface = TAG_INTERFACE_LOOKUP[SVG_NS][name];
+  if (specDefinedInterface !== undefined) {
+    return interfaces.getInterfaceWrapper(specDefinedInterface);
+  }
+
+  return interfaces.getInterfaceWrapper("SVGElement");
+}
+
+// Returns the list of valid tag names that can bo associated with a element given its namespace and name.
+function getValidTagNames(namespace, name) {
+  if (INTERFACE_TAG_MAPPING[namespace] && INTERFACE_TAG_MAPPING[namespace][name]) {
+    return INTERFACE_TAG_MAPPING[namespace][name];
+  }
+
+  return [];
+}
+
+// https://dom.spec.whatwg.org/#concept-create-element
+function createElement(
+  document,
+  localName,
+  namespace,
+  prefix = null,
+  isValue = null,
+  synchronousCE = false
+) {
+  let result = null;
+
+  const { _globalObject } = document;
+  const definition = lookupCEDefinition(document, namespace, localName, isValue);
+
+  if (definition !== null && definition.name !== localName) {
+    const elementInterface = getHTMLElementInterface(localName);
+
+    result = elementInterface.createImpl(_globalObject, [], {
+      ownerDocument: document,
+      localName,
+      namespace: HTML_NS,
+      prefix,
+      ceState: "undefined",
+      ceDefinition: null,
+      isValue
+    });
+
+    if (synchronousCE) {
+      upgradeElement(definition, result);
+    } else {
+      enqueueCEUpgradeReaction(result, definition);
+    }
+  } else if (definition !== null) {
+    if (synchronousCE) {
+      try {
+        const C = definition.ctor;
+
+        const resultWrapper = new C();
+        result = implForWrapper(resultWrapper);
+
+        if (!result._ceState || !result._ceDefinition || result._namespaceURI !== HTML_NS) {
+          throw new TypeError("Internal error: Invalid custom element.");
+        }
+
+        if (result._attributeList.length !== 0) {
+          throw DOMException.create(_globalObject, ["Unexpected attributes.", "NotSupportedError"]);
+        }
+        if (domSymbolTree.hasChildren(result)) {
+          throw DOMException.create(_globalObject, ["Unexpected child nodes.", "NotSupportedError"]);
+        }
+        if (domSymbolTree.parent(result)) {
+          throw DOMException.create(_globalObject, ["Unexpected element parent.", "NotSupportedError"]);
+        }
+        if (result._ownerDocument !== document) {
+          throw DOMException.create(_globalObject, ["Unexpected element owner document.", "NotSupportedError"]);
+        }
+        if (result._namespaceURI !== namespace) {
+          throw DOMException.create(_globalObject, ["Unexpected element namespace URI.", "NotSupportedError"]);
+        }
+        if (result._localName !== localName) {
+          throw DOMException.create(_globalObject, ["Unexpected element local name.", "NotSupportedError"]);
+        }
+
+        result._prefix = prefix;
+        result._isValue = isValue;
+      } catch (error) {
+        reportException(document._defaultView, error);
+
+        const interfaceWrapper = interfaces.getInterfaceWrapper("HTMLUnknownElement");
+        result = interfaceWrapper.createImpl(_globalObject, [], {
+          ownerDocument: document,
+          localName,
+          namespace: HTML_NS,
+          prefix,
+          ceState: "failed",
+          ceDefinition: null,
+          isValue: null
+        });
+      }
+    } else {
+      const interfaceWrapper = interfaces.getInterfaceWrapper("HTMLElement");
+      result = interfaceWrapper.createImpl(_globalObject, [], {
+        ownerDocument: document,
+        localName,
+        namespace: HTML_NS,
+        prefix,
+        ceState: "undefined",
+        ceDefinition: null,
+        isValue: null
+      });
+
+      enqueueCEUpgradeReaction(result, definition);
+    }
+  } else {
+    let elementInterface;
+
+    switch (namespace) {
+      case HTML_NS:
+        elementInterface = getHTMLElementInterface(localName);
+        break;
+
+      case SVG_NS:
+        elementInterface = getSVGInterface(localName);
+        break;
+
+      default:
+        elementInterface = interfaces.getInterfaceWrapper("Element");
+        break;
+    }
+
+    result = elementInterface.createImpl(_globalObject, [], {
+      ownerDocument: document,
+      localName,
+      namespace,
+      prefix,
+      ceState: "uncustomized",
+      ceDefinition: null,
+      isValue
+    });
+
+    if (namespace === HTML_NS && (isValidCustomElementName(localName) || isValue !== null)) {
+      result._ceState = "undefined";
+    }
+  }
+
+  return result;
+}
+
+// https://dom.spec.whatwg.org/#internal-createelementns-steps
+function internalCreateElementNSSteps(document, namespace, qualifiedName, options) {
+  const extracted = validateAndExtract(document._globalObject, namespace, qualifiedName);
+
+  let isValue = null;
+  if (options && options.is !== undefined) {
+    isValue = options.is;
+  }
+
+  return createElement(
+    document,
+    extracted.localName,
+    extracted.namespace,
+    extracted.prefix,
+    isValue,
+    true
+  );
+}
+
+module.exports = {
+  createElement,
+  internalCreateElementNSSteps,
+
+  getValidTagNames,
+  getHTMLElementInterface
+};
diff --git a/lib/jsdom/living/helpers/create-event-accessor.js b/lib/jsdom/living/helpers/create-event-accessor.js
new file mode 100644
index 0000000..4890b80
--- /dev/null
+++ b/lib/jsdom/living/helpers/create-event-accessor.js
@@ -0,0 +1,190 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const idlUtils = require("../generated/utils");
+const ErrorEvent = require("../generated/ErrorEvent");
+const reportException = require("./runtime-script-errors");
+
+exports.appendHandler = function appendHandler(el, eventName) {
+  el.addEventListener(eventName, event => {
+    // https://html.spec.whatwg.org/#the-event-handler-processing-algorithm
+    event = idlUtils.implForWrapper(event);
+
+    const callback = el["on" + eventName];
+    if (callback === null) {
+      return;
+    }
+
+    const specialError = ErrorEvent.isImpl(event) && event.type === "error" &&
+      event.currentTarget.constructor.name === "Window";
+
+    let returnValue = null;
+    const thisValue = idlUtils.tryWrapperForImpl(event.currentTarget);
+    // https://heycam.github.io/webidl/#es-invoking-callback-functions
+    if (typeof callback === "function") {
+      if (specialError) {
+        returnValue = callback.call(
+          thisValue, event.message,
+          event.filename, event.lineno, event.colno, event.error
+        );
+      } else {
+        const eventWrapper = idlUtils.wrapperForImpl(event);
+        returnValue = callback.call(thisValue, eventWrapper);
+      }
+    }
+
+    if (event.type === "beforeunload") { // TODO: we don't implement BeforeUnloadEvent so we can't brand-check here
+      // Perform conversion which in the spec is done by the event handler return type being DOMString?
+      returnValue = returnValue === undefined || returnValue === null ? null : conversions.DOMString(returnValue);
+
+      if (returnValue !== null) {
+        event._canceledFlag = true;
+        if (event.returnValue === "") {
+          event.returnValue = returnValue;
+        }
+      }
+    } else if (specialError) {
+      if (returnValue === true) {
+        event._canceledFlag = true;
+      }
+    } else if (returnValue === false) {
+      event._canceledFlag = true;
+    }
+  });
+};
+
+// "Simple" in this case means "no content attributes involved"
+exports.setupForSimpleEventAccessors = (prototype, events) => {
+  prototype._getEventHandlerFor = function (event) {
+    return this._eventHandlers ? this._eventHandlers[event] : undefined;
+  };
+
+  prototype._setEventHandlerFor = function (event, handler) {
+    if (!this._registeredHandlers) {
+      this._registeredHandlers = new Set();
+      this._eventHandlers = Object.create(null);
+    }
+
+    if (!this._registeredHandlers.has(event) && handler !== null) {
+      this._registeredHandlers.add(event);
+      exports.appendHandler(this, event);
+    }
+    this._eventHandlers[event] = handler;
+  };
+
+  for (const event of events) {
+    exports.createEventAccessor(prototype, event);
+  }
+};
+
+// https://html.spec.whatwg.org/#event-handler-idl-attributes
+exports.createEventAccessor = function createEventAccessor(obj, event) {
+  Object.defineProperty(obj, "on" + event, {
+    configurable: true,
+    enumerable: true,
+    get() { // https://html.spec.whatwg.org/#getting-the-current-value-of-the-event-handler
+      const value = this._getEventHandlerFor(event);
+      if (!value) {
+        return null;
+      }
+
+      if (value.body !== undefined) {
+        let element;
+        let document;
+        if (this.constructor.name === "Window") {
+          element = null;
+          document = idlUtils.implForWrapper(this.document);
+        } else {
+          element = this;
+          document = element.ownerDocument;
+        }
+        const { body } = value;
+
+        const formOwner = element !== null && element.form ? element.form : null;
+        const window = this.constructor.name === "Window" && this._document ? this : document.defaultView;
+
+        try {
+          // eslint-disable-next-line no-new-func
+          Function(body); // properly error out on syntax errors
+          // Note: this won't execute body; that would require `Function(body)()`.
+        } catch (e) {
+          if (window) {
+            reportException(window, e);
+          }
+          this._setEventHandlerFor(event, null);
+          return null;
+        }
+
+        // Note: the with (window) { } is not necessary in Node, but is necessary in a browserified environment.
+
+        let fn;
+        const createFunction = document.defaultView.Function;
+        if (event === "error" && element === null) {
+          const wrapperBody = document ? body + `\n//# sourceURL=${document.URL}` : body;
+
+          // eslint-disable-next-line no-new-func
+          fn = createFunction("window", `with (window) { return function onerror(event, source, lineno, colno, error) {
+  ${wrapperBody}
+}; }`)(window);
+        } else {
+          const argNames = [];
+          const args = [];
+
+          argNames.push("window");
+          args.push(window);
+
+          if (element !== null) {
+            argNames.push("document");
+            args.push(idlUtils.wrapperForImpl(document));
+          }
+          if (formOwner !== null) {
+            argNames.push("formOwner");
+            args.push(idlUtils.wrapperForImpl(formOwner));
+          }
+          if (element !== null) {
+            argNames.push("element");
+            args.push(idlUtils.wrapperForImpl(element));
+          }
+          let wrapperBody = `
+return function on${event}(event) {
+  ${body}
+};`;
+          for (let i = argNames.length - 1; i >= 0; --i) {
+            wrapperBody = `with (${argNames[i]}) { ${wrapperBody} }`;
+          }
+          if (document) {
+            wrapperBody += `\n//# sourceURL=${document.URL}`;
+          }
+          argNames.push(wrapperBody);
+          fn = createFunction(...argNames)(...args);
+        }
+
+        this._setEventHandlerFor(event, fn);
+      }
+      return this._getEventHandlerFor(event);
+    },
+    set(val) {
+      val = eventHandlerArgCoercion(val);
+      this._setEventHandlerFor(event, val);
+    }
+  });
+};
+
+function typeIsObject(v) {
+  return (typeof v === "object" && v !== null) || typeof v === "function";
+}
+
+// Implements:
+//     [TreatNonObjectAsNull]
+//     callback EventHandlerNonNull = any (Event event);
+//     typedef EventHandlerNonNull? EventHandler;
+// Also implements the part of https://heycam.github.io/webidl/#es-invoking-callback-functions which treats
+// non-callable callback functions as callback functions that return undefined.
+// TODO: replace with webidl2js typechecking when it has sufficient callback support
+function eventHandlerArgCoercion(val) {
+  if (!typeIsObject(val)) {
+    return null;
+  }
+
+  return val;
+}
diff --git a/lib/jsdom/living/helpers/custom-elements.js b/lib/jsdom/living/helpers/custom-elements.js
new file mode 100644
index 0000000..2ca7d7b
--- /dev/null
+++ b/lib/jsdom/living/helpers/custom-elements.js
@@ -0,0 +1,268 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const isPotentialCustomElementName = require("is-potential-custom-element-name");
+
+const NODE_TYPE = require("../node-type");
+const { HTML_NS } = require("./namespaces");
+const { shadowIncludingRoot } = require("./shadow-dom");
+const reportException = require("./runtime-script-errors");
+
+const { implForWrapper, wrapperForImpl } = require("../generated/utils");
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#custom-element-reactions-stack
+class CEReactionsStack {
+  constructor() {
+    this._stack = [];
+
+    // https://html.spec.whatwg.org/multipage/custom-elements.html#backup-element-queue
+    this.backupElementQueue = [];
+
+    // https://html.spec.whatwg.org/multipage/custom-elements.html#processing-the-backup-element-queue
+    this.processingBackupElementQueue = false;
+  }
+
+  push(elementQueue) {
+    this._stack.push(elementQueue);
+  }
+
+  pop() {
+    return this._stack.pop();
+  }
+
+  get currentElementQueue() {
+    const { _stack } = this;
+    return _stack[_stack.length - 1];
+  }
+
+  isEmpty() {
+    return this._stack.length === 0;
+  }
+}
+
+// In theory separate cross-origin Windows created by separate JSDOM instances could have separate stacks. But, we would
+// need to implement the whole agent architecture. Which is kind of questionable given that we don't run our Windows in
+// their own separate threads, which is what agents are meant to represent.
+const customElementReactionsStack = new CEReactionsStack();
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#cereactions
+function ceReactionsPreSteps() {
+  customElementReactionsStack.push([]);
+}
+function ceReactionsPostSteps() {
+  const queue = customElementReactionsStack.pop();
+  invokeCEReactions(queue);
+}
+
+const RESTRICTED_CUSTOM_ELEMENT_NAME = new Set([
+  "annotation-xml",
+  "color-profile",
+  "font-face",
+  "font-face-src",
+  "font-face-uri",
+  "font-face-format",
+  "font-face-name",
+  "missing-glyph"
+]);
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+function isValidCustomElementName(name) {
+  if (RESTRICTED_CUSTOM_ELEMENT_NAME.has(name)) {
+    return false;
+  }
+
+  return isPotentialCustomElementName(name);
+}
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#concept-upgrade-an-element
+function upgradeElement(definition, element) {
+  if (element._ceState !== "undefined" || element._ceState === "uncustomized") {
+    return;
+  }
+
+  element._ceDefinition = definition;
+  element._ceState = "failed";
+
+  for (const attribute of element._attributeList) {
+    const { _localName, _namespace, _value } = attribute;
+    enqueueCECallbackReaction(element, "attributeChangedCallback", [_localName, null, _value, _namespace]);
+  }
+
+  if (shadowIncludingRoot(element).nodeType === NODE_TYPE.DOCUMENT_NODE) {
+    enqueueCECallbackReaction(element, "connectedCallback", []);
+  }
+
+  definition.constructionStack.push(element);
+
+  const { constructionStack, ctor: C } = definition;
+
+  let constructionError;
+  try {
+    if (definition.disableShadow === true && element._shadowRoot !== null) {
+      throw DOMException.create(element._globalObject, [
+        "Can't upgrade a custom element with a shadow root if shadow is disabled",
+        "NotSupportedError"
+      ]);
+    }
+
+    const constructionResult = new C();
+    const constructionResultImpl = implForWrapper(constructionResult);
+
+    if (constructionResultImpl !== element) {
+      throw new TypeError("Invalid custom element constructor return value");
+    }
+  } catch (error) {
+    constructionError = error;
+  }
+
+  constructionStack.pop();
+
+  if (constructionError !== undefined) {
+    element._ceDefinition = null;
+    element._ceReactionQueue = [];
+
+    throw constructionError;
+  }
+
+  element._ceState = "custom";
+}
+
+// https://html.spec.whatwg.org/#concept-try-upgrade
+function tryUpgradeElement(element) {
+  const { _ownerDocument, _namespaceURI, _localName, _isValue } = element;
+  const definition = lookupCEDefinition(_ownerDocument, _namespaceURI, _localName, _isValue);
+
+  if (definition !== null) {
+    enqueueCEUpgradeReaction(element, definition);
+  }
+}
+
+// https://html.spec.whatwg.org/#look-up-a-custom-element-definition
+function lookupCEDefinition(document, namespace, localName, isValue) {
+  const definition = null;
+
+  if (namespace !== HTML_NS) {
+    return definition;
+  }
+
+  if (!document._defaultView) {
+    return definition;
+  }
+
+  const registry = implForWrapper(document._globalObject.customElements);
+
+  const definitionByName = registry._customElementDefinitions.find(def => {
+    return def.name === def.localName && def.localName === localName;
+  });
+  if (definitionByName !== undefined) {
+    return definitionByName;
+  }
+
+  const definitionByIs = registry._customElementDefinitions.find(def => {
+    return def.name === isValue && def.localName === localName;
+  });
+  if (definitionByIs !== undefined) {
+    return definitionByIs;
+  }
+
+  return definition;
+}
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#invoke-custom-element-reactions
+function invokeCEReactions(elementQueue) {
+  for (const element of elementQueue) {
+    const reactions = element._ceReactionQueue;
+
+    try {
+      while (reactions.length > 0) {
+        const reaction = reactions.shift();
+
+        switch (reaction.type) {
+          case "upgrade":
+            upgradeElement(reaction.definition, element);
+            break;
+
+          case "callback":
+            reaction.callback.apply(wrapperForImpl(element), reaction.args);
+            break;
+        }
+      }
+    } catch (error) {
+      reportException(element._globalObject, error);
+    }
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#enqueue-an-element-on-the-appropriate-element-queue
+function enqueueElementOnAppropriateElementQueue(element) {
+  if (customElementReactionsStack.isEmpty()) {
+    customElementReactionsStack.backupElementQueue.push(element);
+
+    if (customElementReactionsStack.processingBackupElementQueue) {
+      return;
+    }
+
+    customElementReactionsStack.processingBackupElementQueue = true;
+
+    Promise.resolve().then(() => {
+      const elementQueue = customElementReactionsStack.backupElementQueue;
+      invokeCEReactions(elementQueue);
+
+      customElementReactionsStack.processingBackupElementQueue = false;
+    });
+  } else {
+    customElementReactionsStack.currentElementQueue.push(element);
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#enqueue-a-custom-element-callback-reaction
+function enqueueCECallbackReaction(element, callbackName, args) {
+  const { _ceDefinition: { lifecycleCallbacks, observedAttributes } } = element;
+
+  const callback = lifecycleCallbacks[callbackName];
+  if (callback === null) {
+    return;
+  }
+
+  if (callbackName === "attributeChangedCallback") {
+    const attributeName = args[0];
+    if (!observedAttributes.includes(attributeName)) {
+      return;
+    }
+  }
+
+  element._ceReactionQueue.push({
+    type: "callback",
+    callback,
+    args
+  });
+
+  enqueueElementOnAppropriateElementQueue(element);
+}
+
+// https://html.spec.whatwg.org/#enqueue-a-custom-element-upgrade-reaction
+function enqueueCEUpgradeReaction(element, definition) {
+  element._ceReactionQueue.push({
+    type: "upgrade",
+    definition
+  });
+
+  enqueueElementOnAppropriateElementQueue(element);
+}
+
+module.exports = {
+  customElementReactionsStack,
+
+  ceReactionsPreSteps,
+  ceReactionsPostSteps,
+
+  isValidCustomElementName,
+
+  upgradeElement,
+  tryUpgradeElement,
+
+  lookupCEDefinition,
+  enqueueCEUpgradeReaction,
+  enqueueCECallbackReaction,
+  invokeCEReactions
+};
diff --git a/lib/jsdom/living/helpers/dates-and-times.js b/lib/jsdom/living/helpers/dates-and-times.js
new file mode 100644
index 0000000..fd1ce2e
--- /dev/null
+++ b/lib/jsdom/living/helpers/dates-and-times.js
@@ -0,0 +1,270 @@
+"use strict";
+
+function isLeapYear(year) {
+  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#number-of-days-in-month-month-of-year-year
+const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function numberOfDaysInMonthOfYear(month, year) {
+  if (month === 2 && isLeapYear(year)) {
+    return 29;
+  }
+  return daysInMonth[month - 1];
+}
+
+const monthRe = /^([0-9]{4,})-([0-9]{2})$/;
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-month-string
+function parseMonthString(str) {
+  const matches = monthRe.exec(str);
+  if (!matches) {
+    return null;
+  }
+  const year = Number(matches[1]);
+  if (year <= 0) {
+    return null;
+  }
+  const month = Number(matches[2]);
+  if (month < 1 || month > 12) {
+    return null;
+  }
+  return { year, month };
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-month-string
+function isValidMonthString(str) {
+  return parseMonthString(str) !== null;
+}
+function serializeMonth({ year, month }) {
+  const yearStr = `${year}`.padStart(4, "0");
+  const monthStr = `${month}`.padStart(2, "0");
+  return `${yearStr}-${monthStr}`;
+}
+
+const dateRe = /^([0-9]{4,})-([0-9]{2})-([0-9]{2})$/;
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-date-string
+function parseDateString(str) {
+  const matches = dateRe.exec(str);
+  if (!matches) {
+    return null;
+  }
+  const year = Number(matches[1]);
+  if (year <= 0) {
+    return null;
+  }
+  const month = Number(matches[2]);
+  if (month < 1 || month > 12) {
+    return null;
+  }
+  const day = Number(matches[3]);
+  if (day < 1 || day > numberOfDaysInMonthOfYear(month, year)) {
+    return null;
+  }
+  return { year, month, day };
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-date-string
+function isValidDateString(str) {
+  return parseDateString(str) !== null;
+}
+function serializeDate(date) {
+  const dayStr = `${date.day}`.padStart(2, "0");
+  return `${serializeMonth(date)}-${dayStr}`;
+}
+
+const yearlessDateRe = /^(?:--)?([0-9]{2})-([0-9]{2})$/;
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-yearless-date-string
+function parseYearlessDateString(str) {
+  const matches = yearlessDateRe.exec(str);
+  if (!matches) {
+    return null;
+  }
+  const month = Number(matches[1]);
+  if (month < 1 || month > 12) {
+    return null;
+  }
+  const day = Number(matches[2]);
+  if (day < 1 || day > numberOfDaysInMonthOfYear(month, 4)) {
+    return null;
+  }
+  return { month, day };
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-yearless-date-string
+function isValidYearlessDateString(str) {
+  return parseYearlessDateString(str) !== null;
+}
+function serializeYearlessDate({ month, day }) {
+  const monthStr = `${month}`.padStart(2, "0");
+  const dayStr = `${day}`.padStart(2, "0");
+  return `${monthStr}-${dayStr}`;
+}
+
+const timeRe = /^([0-9]{2}):([0-9]{2})(?::([0-9]{2}(?:\.([0-9]{1,3}))?))?$/;
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-time-string
+function parseTimeString(str) {
+  const matches = timeRe.exec(str);
+  if (!matches) {
+    return null;
+  }
+  const hour = Number(matches[1]);
+  if (hour < 0 || hour > 23) {
+    return null;
+  }
+  const minute = Number(matches[2]);
+  if (minute < 0 || minute > 59) {
+    return null;
+  }
+  const second = matches[3] !== undefined ? Math.trunc(Number(matches[3])) : 0;
+  if (second < 0 || second >= 60) {
+    return null;
+  }
+  const millisecond = matches[4] !== undefined ? Number(matches[4]) : 0;
+  return { hour, minute, second, millisecond };
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-time-string
+function isValidTimeString(str) {
+  return parseTimeString(str) !== null;
+}
+
+function serializeTime({ hour, minute, second, millisecond }) {
+  const hourStr = `${hour}`.padStart(2, "0");
+  const minuteStr = `${minute}`.padStart(2, "0");
+  if (second === 0 && millisecond === 0) {
+    return `${hourStr}:${minuteStr}`;
+  }
+  const secondStr = `${second}`.padStart(2, "0");
+  const millisecondStr = `${millisecond}`.padStart(3, "0");
+  return `${hourStr}:${minuteStr}:${secondStr}.${millisecondStr}`;
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-local-date-and-time-string
+function parseLocalDateAndTimeString(str, normalized = false) {
+  let separatorIdx = str.indexOf("T");
+  if (separatorIdx < 0 && !normalized) {
+    separatorIdx = str.indexOf(" ");
+  }
+  if (separatorIdx < 0) {
+    return null;
+  }
+  const date = parseDateString(str.slice(0, separatorIdx));
+  if (date === null) {
+    return null;
+  }
+  const time = parseTimeString(str.slice(separatorIdx + 1));
+  if (time === null) {
+    return null;
+  }
+  return { date, time };
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-local-date-and-time-string
+function isValidLocalDateAndTimeString(str) {
+  return parseLocalDateAndTimeString(str) !== null;
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-normalised-local-date-and-time-string
+function isValidNormalizedLocalDateAndTimeString(str) {
+  return parseLocalDateAndTimeString(str, true) !== null;
+}
+function serializeNormalizedDateAndTime({ date, time }) {
+  return `${serializeDate(date)}T${serializeTime(time)}`;
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#week-number-of-the-last-day
+// https://stackoverflow.com/a/18538272/1937836
+function weekNumberOfLastDay(year) {
+  const jan1 = new Date(year, 0);
+  return jan1.getDay() === 4 || (isLeapYear(year) && jan1.getDay() === 3) ? 53 : 52;
+}
+
+const weekRe = /^([0-9]{4,5})-W([0-9]{2})$/;
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-week-string
+function parseWeekString(str) {
+  const matches = weekRe.exec(str);
+  if (!matches) {
+    return null;
+  }
+  const year = Number(matches[1]);
+  if (year <= 0) {
+    return null;
+  }
+  const week = Number(matches[2]);
+  if (week < 1 || week > weekNumberOfLastDay(year)) {
+    return null;
+  }
+  return { year, week };
+}
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-week-string
+function isValidWeekString(str) {
+  return parseWeekString(str) !== null;
+}
+function serializeWeek({ year, week }) {
+  const yearStr = `${year}`.padStart(4, "0");
+  const weekStr = `${week}`.padStart(2, "0");
+  return `${yearStr}-W${weekStr}`;
+}
+
+// https://stackoverflow.com/a/6117889
+function parseDateAsWeek(originalDate) {
+  const dayInSeconds = 86400000;
+  // Copy date so don't modify original
+  const date = new Date(Date.UTC(originalDate.getUTCFullYear(), originalDate.getUTCMonth(), originalDate.getUTCDate()));
+  // Set to nearest Thursday: current date + 4 - current day number
+  // Make Sunday's day number 7
+  date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
+  // Get first day of year
+  const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+  // Calculate full weeks to nearest Thursday
+  const week = Math.ceil((((date - yearStart) / dayInSeconds) + 1) / 7);
+
+  return { year: date.getUTCFullYear(), week };
+}
+
+function isDate(obj) {
+  try {
+    Date.prototype.valueOf.call(obj);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  isDate,
+  numberOfDaysInMonthOfYear,
+
+  parseMonthString,
+  isValidMonthString,
+  serializeMonth,
+
+  parseDateString,
+  isValidDateString,
+  serializeDate,
+
+  parseYearlessDateString,
+  isValidYearlessDateString,
+  serializeYearlessDate,
+
+  parseTimeString,
+  isValidTimeString,
+  serializeTime,
+
+  parseLocalDateAndTimeString,
+  isValidLocalDateAndTimeString,
+  isValidNormalizedLocalDateAndTimeString,
+  serializeNormalizedDateAndTime,
+
+  parseDateAsWeek,
+  weekNumberOfLastDay,
+  parseWeekString,
+  isValidWeekString,
+  serializeWeek
+};
diff --git a/lib/jsdom/living/helpers/details.js b/lib/jsdom/living/helpers/details.js
new file mode 100644
index 0000000..25c5387
--- /dev/null
+++ b/lib/jsdom/living/helpers/details.js
@@ -0,0 +1,15 @@
+"use strict";
+const { firstChildWithLocalName } = require("./traversal");
+const { HTML_NS } = require("./namespaces");
+
+// https://html.spec.whatwg.org/multipage/interactive-elements.html#summary-for-its-parent-details
+exports.isSummaryForParentDetails = summaryElement => {
+  const parent = summaryElement.parentNode;
+  if (parent === null) {
+    return false;
+  }
+  if (parent._localName !== "details" || parent._namespaceURI !== HTML_NS) {
+    return false;
+  }
+  return firstChildWithLocalName(parent, "summary") === summaryElement;
+};
diff --git a/lib/jsdom/living/helpers/document-base-url.js b/lib/jsdom/living/helpers/document-base-url.js
new file mode 100644
index 0000000..7781946
--- /dev/null
+++ b/lib/jsdom/living/helpers/document-base-url.js
@@ -0,0 +1,52 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+
+exports.documentBaseURL = document => {
+  // https://html.spec.whatwg.org/multipage/infrastructure.html#document-base-url
+
+  const firstBase = document.querySelector("base[href]");
+  const fallbackBaseURL = exports.fallbackBaseURL(document);
+
+  if (firstBase === null) {
+    return fallbackBaseURL;
+  }
+
+  return frozenBaseURL(firstBase, fallbackBaseURL);
+};
+
+exports.documentBaseURLSerialized = document => {
+  return whatwgURL.serializeURL(exports.documentBaseURL(document));
+};
+
+exports.fallbackBaseURL = document => {
+  // https://html.spec.whatwg.org/multipage/infrastructure.html#fallback-base-url
+
+  // Unimplemented: <iframe srcdoc>
+
+  if (document.URL === "about:blank" && document._defaultView &&
+      document._defaultView._parent !== document._defaultView) {
+    return exports.documentBaseURL(document._defaultView._parent._document);
+  }
+
+  return document._URL;
+};
+
+exports.parseURLToResultingURLRecord = (url, document) => {
+  // https://html.spec.whatwg.org/#resolve-a-url
+
+  // Encoding stuff ignored; always UTF-8 for us, for now.
+
+  const baseURL = exports.documentBaseURL(document);
+
+  return whatwgURL.parseURL(url, { baseURL });
+  // This returns the resulting URL record; to get the resulting URL string, just serialize it.
+};
+
+function frozenBaseURL(baseElement, fallbackBaseURL) {
+  // https://html.spec.whatwg.org/multipage/semantics.html#frozen-base-url
+  // The spec is eager (setting the frozen base URL when things change); we are lazy (getting it when we need to)
+
+  const baseHrefAttribute = baseElement.getAttributeNS(null, "href");
+  const result = whatwgURL.parseURL(baseHrefAttribute, { baseURL: fallbackBaseURL });
+  return result === null ? fallbackBaseURL : result;
+}
diff --git a/lib/jsdom/living/helpers/events.js b/lib/jsdom/living/helpers/events.js
new file mode 100644
index 0000000..cd65a38
--- /dev/null
+++ b/lib/jsdom/living/helpers/events.js
@@ -0,0 +1,24 @@
+"use strict";
+
+const Event = require("../generated/Event");
+const { tryImplForWrapper } = require("../generated/utils");
+
+function createAnEvent(e, globalObject, eventInterface = Event, attributes = {}) {
+  return eventInterface.createImpl(
+    globalObject,
+    [e, attributes],
+    { isTrusted: attributes.isTrusted !== false }
+  );
+}
+
+function fireAnEvent(e, target, eventInterface, attributes, legacyTargetOverrideFlag) {
+  const event = createAnEvent(e, target._globalObject, eventInterface, attributes);
+
+  // tryImplForWrapper() is currently required due to use in Window.js
+  return tryImplForWrapper(target)._dispatch(event, legacyTargetOverrideFlag);
+}
+
+module.exports = {
+  createAnEvent,
+  fireAnEvent
+};
diff --git a/lib/jsdom/living/helpers/focusing.js b/lib/jsdom/living/helpers/focusing.js
new file mode 100644
index 0000000..7ca184b
--- /dev/null
+++ b/lib/jsdom/living/helpers/focusing.js
@@ -0,0 +1,76 @@
+"use strict";
+const nodeType = require("../node-type.js");
+const FocusEvent = require("../generated/FocusEvent.js");
+const idlUtils = require("../generated/utils.js");
+const { isDisabled } = require("./form-controls.js");
+const { firstChildWithLocalName } = require("./traversal");
+const { createAnEvent } = require("./events");
+const { HTML_NS } = require("./namespaces");
+
+const focusableFormElements = new Set(["input", "select", "textarea", "button"]);
+
+// https://html.spec.whatwg.org/multipage/interaction.html#focusable-area, but also some of
+// https://html.spec.whatwg.org/multipage/interaction.html#focusing-steps: e.g., Documents are not actually focusable
+// areas, but their viewports are, and the first step of the latter algorithm translates Documents to their viewports.
+// And also https://html.spec.whatwg.org/multipage/interaction.html#specially-focusable!
+exports.isFocusableAreaElement = elImpl => {
+  if (!elImpl._ownerDocument._defaultView && !elImpl._defaultView) {
+    return false;
+  }
+
+  if (elImpl._nodeType === nodeType.DOCUMENT_NODE) {
+    return true;
+  }
+
+  if (!Number.isNaN(parseInt(elImpl.getAttributeNS(null, "tabindex")))) {
+    return true;
+  }
+
+  if (elImpl._namespaceURI === HTML_NS) {
+    if (elImpl._localName === "iframe") {
+      return true;
+    }
+
+    if (elImpl._localName === "a" && elImpl.hasAttributeNS(null, "href")) {
+      return true;
+    }
+
+    if (elImpl._localName === "summary" && elImpl.parentNode &&
+        elImpl.parentNode._localName === "details" &&
+        elImpl === firstChildWithLocalName(elImpl.parentNode, "summary")) {
+      return true;
+    }
+
+    if (focusableFormElements.has(elImpl._localName) && !isDisabled(elImpl)) {
+      if (elImpl._localName === "input" && elImpl.type === "hidden") {
+        return false;
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+};
+
+// https://html.spec.whatwg.org/multipage/interaction.html#fire-a-focus-event plus the steps of
+// https://html.spec.whatwg.org/multipage/interaction.html#focus-update-steps that adjust Documents to Windows
+exports.fireFocusEventWithTargetAdjustment = (name, target, relatedTarget) => {
+  if (target === null) {
+    // E.g. firing blur with nothing previously focused.
+    return;
+  }
+
+  const event = createAnEvent(name, target._globalObject, FocusEvent, {
+    composed: true,
+    relatedTarget,
+    view: target._ownerDocument._defaultView,
+    detail: 0
+  });
+
+  if (target._defaultView) {
+    target = idlUtils.implForWrapper(target._defaultView);
+  }
+
+  target._dispatch(event);
+};
diff --git a/lib/jsdom/living/helpers/form-controls.js b/lib/jsdom/living/helpers/form-controls.js
new file mode 100644
index 0000000..1281730
--- /dev/null
+++ b/lib/jsdom/living/helpers/form-controls.js
@@ -0,0 +1,272 @@
+"use strict";
+
+const {
+  isValidFloatingPointNumber,
+  isValidSimpleColor,
+  parseFloatingPointNumber,
+  stripLeadingAndTrailingASCIIWhitespace,
+  stripNewlines,
+  splitOnCommas
+} = require("./strings");
+const {
+  isValidDateString,
+  isValidMonthString,
+  isValidTimeString,
+  isValidWeekString,
+  parseLocalDateAndTimeString,
+  serializeNormalizedDateAndTime
+} = require("./dates-and-times");
+const whatwgURL = require("whatwg-url");
+
+const NodeList = require("../generated/NodeList");
+const { domSymbolTree } = require("./internal-constants");
+const { closest, firstChildWithLocalName } = require("./traversal");
+const NODE_TYPE = require("../node-type");
+const { HTML_NS } = require("./namespaces");
+
+// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-fe-disabled
+exports.isDisabled = formControl => {
+  if (formControl.localName === "button" || formControl.localName === "input" || formControl.localName === "select" ||
+      formControl.localName === "textarea") {
+    if (formControl.hasAttributeNS(null, "disabled")) {
+      return true;
+    }
+  }
+
+  let e = formControl.parentNode;
+  while (e) {
+    if (e.localName === "fieldset" && e.hasAttributeNS(null, "disabled")) {
+      const firstLegendElementChild = firstChildWithLocalName(e, "legend");
+      if (!firstLegendElementChild || !firstLegendElementChild.contains(formControl)) {
+        return true;
+      }
+    }
+    e = e.parentNode;
+  }
+
+  return false;
+};
+
+// https://html.spec.whatwg.org/multipage/forms.html#category-listed
+const listedElements = new Set(["button", "fieldset", "input", "object", "output", "select", "textarea"]);
+exports.isListed = formControl => listedElements.has(formControl._localName) && formControl.namespaceURI === HTML_NS;
+
+// https://html.spec.whatwg.org/multipage/forms.html#category-submit
+const submittableElements = new Set(["button", "input", "object", "select", "textarea"]);
+exports.isSubmittable = formControl => {
+  return submittableElements.has(formControl._localName) && formControl.namespaceURI === HTML_NS;
+};
+
+// https://html.spec.whatwg.org/multipage/forms.html#concept-submit-button
+const submitButtonInputTypes = new Set(["submit", "image"]);
+exports.isSubmitButton = formControl => {
+  return ((formControl._localName === "input" && submitButtonInputTypes.has(formControl.type)) ||
+          (formControl._localName === "button" && formControl.type === "submit")) &&
+         formControl.namespaceURI === HTML_NS;
+};
+
+// https://html.spec.whatwg.org/multipage/forms.html#concept-button
+const buttonInputTypes = new Set([...submitButtonInputTypes, "reset", "button"]);
+exports.isButton = formControl => {
+  return ((formControl._localName === "input" && buttonInputTypes.has(formControl.type)) ||
+          formControl._localName === "button") &&
+         formControl.namespaceURI === HTML_NS;
+};
+
+exports.normalizeToCRLF = string => {
+  return string.replace(/\r([^\n])/g, "\r\n$1")
+    .replace(/\r$/, "\r\n")
+    .replace(/([^\r])\n/g, "$1\r\n")
+    .replace(/^\n/, "\r\n");
+};
+
+exports.isLabelable = node => {
+  // labelable logic defined at: https://html.spec.whatwg.org/multipage/forms.html#category-label
+  if (node.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+    return false;
+  }
+
+  switch (node.tagName) {
+    case "BUTTON":
+    case "METER":
+    case "OUTPUT":
+    case "PROGRESS":
+    case "SELECT":
+    case "TEXTAREA":
+      return true;
+
+    case "INPUT":
+      return node.type !== "hidden";
+  }
+
+  return false;
+};
+
+exports.getLabelsForLabelable = labelable => {
+  if (!exports.isLabelable(labelable)) {
+    return null;
+  }
+  if (!labelable._labels) {
+    const root = labelable.getRootNode({});
+    labelable._labels = NodeList.create(root._globalObject, [], {
+      element: root,
+      query: () => {
+        const nodes = [];
+        for (const descendant of domSymbolTree.treeIterator(root)) {
+          if (descendant.control === labelable) {
+            nodes.push(descendant);
+          }
+        }
+        return nodes;
+      }
+    });
+  }
+  return labelable._labels;
+};
+
+// https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
+exports.isValidEmailAddress = (emailAddress, multiple = false) => {
+  const emailAddressRegExp = new RegExp("^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9]" +
+    "(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}" +
+    "[a-zA-Z0-9])?)*$");
+  // A valid e-mail address list is a set of comma-separated tokens, where each token is itself
+  // a valid e - mail address.To obtain the list of tokens from a valid e - mail address list,
+  // an implementation must split the string on commas.
+  if (multiple) {
+    return splitOnCommas(emailAddress).every(value => emailAddressRegExp.test(value));
+  }
+  return emailAddressRegExp.test(emailAddress);
+};
+
+exports.isValidAbsoluteURL = url => {
+  return whatwgURL.parseURL(url) !== null;
+};
+
+exports.sanitizeValueByType = (input, val) => {
+  switch (input.type.toLowerCase()) {
+    case "password":
+    case "search":
+    case "tel":
+    case "text":
+      val = stripNewlines(val);
+      break;
+
+    case "color":
+      // https://html.spec.whatwg.org/multipage/forms.html#color-state-(type=color):value-sanitization-algorithm
+      val = isValidSimpleColor(val) ? val.toLowerCase() : "#000000";
+      break;
+
+    case "date":
+      // https://html.spec.whatwg.org/multipage/input.html#date-state-(type=date):value-sanitization-algorithm
+      if (!isValidDateString(val)) {
+        val = "";
+      }
+      break;
+
+    case "datetime-local": {
+      // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type=datetime-local):value-sanitization-algorithm
+      const dateAndTime = parseLocalDateAndTimeString(val);
+      val = dateAndTime !== null ? serializeNormalizedDateAndTime(dateAndTime) : "";
+      break;
+    }
+
+    case "email":
+      // https://html.spec.whatwg.org/multipage/forms.html#e-mail-state-(type=email):value-sanitization-algorithm
+      // https://html.spec.whatwg.org/multipage/forms.html#e-mail-state-(type=email):value-sanitization-algorithm-2
+      if (input.hasAttributeNS(null, "multiple")) {
+        val = val.split(",").map(token => stripLeadingAndTrailingASCIIWhitespace(token)).join(",");
+      } else {
+        val = stripNewlines(val);
+        val = stripLeadingAndTrailingASCIIWhitespace(val);
+      }
+      break;
+
+    case "month":
+      // https://html.spec.whatwg.org/multipage/input.html#month-state-(type=month):value-sanitization-algorithm
+      if (!isValidMonthString(val)) {
+        val = "";
+      }
+      break;
+
+    case "number":
+      // https://html.spec.whatwg.org/multipage/input.html#number-state-(type=number):value-sanitization-algorithm
+      // TODO: using parseFloatingPointNumber in addition to isValidFloatingPointNumber to pass number.html WPT.
+      // Possible spec bug.
+      if (!isValidFloatingPointNumber(val) || parseFloatingPointNumber(val) === null) {
+        val = "";
+      }
+      break;
+
+    case "range":
+      // https://html.spec.whatwg.org/multipage/input.html#range-state-(type=range):value-sanitization-algorithm
+      // TODO: using parseFloatingPointNumber in addition to isValidFloatingPointNumber to pass number.html WPT.
+      // Possible spec bug.
+      if (!isValidFloatingPointNumber(val) || parseFloatingPointNumber(val) === null) {
+        const minimum = input._minimum;
+        const maximum = input._maximum;
+        const defaultValue = maximum < minimum ? minimum : (minimum + maximum) / 2;
+        val = `${defaultValue}`;
+      } else if (val < input._minimum) {
+        val = `${input._minimum}`;
+      } else if (val > input._maximum) {
+        val = `${input._maximum}`;
+      }
+      break;
+
+    case "time":
+      // https://html.spec.whatwg.org/multipage/input.html#time-state-(type=time):value-sanitization-algorithm
+      if (!isValidTimeString(val)) {
+        val = "";
+      }
+      break;
+
+    case "url":
+      // https://html.spec.whatwg.org/multipage/forms.html#url-state-(type=url):value-sanitization-algorithm
+      val = stripNewlines(val);
+      val = stripLeadingAndTrailingASCIIWhitespace(val);
+      break;
+
+    case "week":
+      // https://html.spec.whatwg.org/multipage/input.html#week-state-(type=week):value-sanitization-algorithm
+      if (!isValidWeekString(val)) {
+        val = "";
+      }
+  }
+
+  return val;
+};
+
+// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#form-owner
+// TODO: The spec describes an imperative process for assigning/resetting an element's form
+// owner based on activities involving form-associated elements. This simpler implementation
+// instead calculates the current form owner only when the property is accessed. This is not
+// sufficient to pass all the web platform tests, but is good enough for most purposes. We
+// should eventually update it to use the correct version, though. See
+// https://github.com/whatwg/html/issues/4050 for some discussion.
+
+exports.formOwner = formControl => {
+  const formAttr = formControl.getAttributeNS(null, "form");
+  if (formAttr === "") {
+    return null;
+  }
+  if (formAttr === null) {
+    return closest(formControl, "form");
+  }
+
+  const root = formControl.getRootNode({});
+  let firstElementWithId;
+  for (const descendant of domSymbolTree.treeIterator(root)) {
+    if (descendant.nodeType === NODE_TYPE.ELEMENT_NODE &&
+      descendant.getAttributeNS(null, "id") === formAttr) {
+      firstElementWithId = descendant;
+      break;
+    }
+  }
+
+  if (firstElementWithId &&
+    firstElementWithId.namespaceURI === HTML_NS &&
+    firstElementWithId.localName === "form") {
+    return firstElementWithId;
+  }
+  return null;
+};
diff --git a/lib/jsdom/living/helpers/html-constructor.js b/lib/jsdom/living/helpers/html-constructor.js
new file mode 100644
index 0000000..2f781fa
--- /dev/null
+++ b/lib/jsdom/living/helpers/html-constructor.js
@@ -0,0 +1,78 @@
+"use strict";
+
+const { HTML_NS } = require("./namespaces");
+const { createElement, getValidTagNames } = require("./create-element");
+
+const { implForWrapper, wrapperForImpl } = require("../generated/utils");
+
+// https://html.spec.whatwg.org/multipage/custom-elements.html#concept-already-constructed-marker
+const ALREADY_CONSTRUCTED_MARKER = Symbol("already-constructed-marker");
+
+// https://html.spec.whatwg.org/multipage/dom.html#htmlconstructor
+function HTMLConstructor(globalObject, constructorName, newTarget) {
+  const registry = implForWrapper(globalObject.customElements);
+  if (newTarget === HTMLConstructor) {
+    throw new TypeError("Invalid constructor");
+  }
+
+  const definition = registry._customElementDefinitions.find(entry => entry.ctor === newTarget);
+  if (definition === undefined) {
+    throw new TypeError("Invalid constructor, the constructor is not part of the custom element registry");
+  }
+
+  let isValue = null;
+
+  if (definition.localName === definition.name) {
+    if (constructorName !== "HTMLElement") {
+      throw new TypeError("Invalid constructor, autonomous custom element should extend from HTMLElement");
+    }
+  } else {
+    const validLocalNames = getValidTagNames(HTML_NS, constructorName);
+    if (!validLocalNames.includes(definition.localName)) {
+      throw new TypeError(`${definition.localName} is not valid local name for ${constructorName}`);
+    }
+
+    isValue = definition.name;
+  }
+
+  let { prototype } = newTarget;
+
+  if (prototype === null || typeof prototype !== "object") {
+    // The following line deviates from the specification. The HTMLElement prototype should be retrieved from the realm
+    // associated with the "new.target". Because it is impossible to get such information in jsdom, we fallback to the
+    // HTMLElement prototype associated with the current object.
+    prototype = globalObject.HTMLElement.prototype;
+  }
+
+  if (definition.constructionStack.length === 0) {
+    const documentImpl = implForWrapper(globalObject.document);
+
+    const elementImpl = createElement(documentImpl, definition.localName, HTML_NS);
+
+    const element = wrapperForImpl(elementImpl);
+    Object.setPrototypeOf(element, prototype);
+
+    elementImpl._ceState = "custom";
+    elementImpl._ceDefinition = definition;
+    elementImpl._isValue = isValue;
+
+    return element;
+  }
+
+  const elementImpl = definition.constructionStack[definition.constructionStack.length - 1];
+  const element = wrapperForImpl(elementImpl);
+
+  if (elementImpl === ALREADY_CONSTRUCTED_MARKER) {
+    throw new TypeError("This instance is already constructed");
+  }
+
+  Object.setPrototypeOf(element, prototype);
+
+  definition.constructionStack[definition.constructionStack.length - 1] = ALREADY_CONSTRUCTED_MARKER;
+
+  return element;
+}
+
+module.exports = {
+  HTMLConstructor
+};
diff --git a/lib/jsdom/living/helpers/internal-constants.js b/lib/jsdom/living/helpers/internal-constants.js
new file mode 100644
index 0000000..707add9
--- /dev/null
+++ b/lib/jsdom/living/helpers/internal-constants.js
@@ -0,0 +1,12 @@
+"use strict";
+const SymbolTree = require("symbol-tree");
+
+exports.cloningSteps = Symbol("cloning steps");
+
+// TODO: the many underscore-prefixed hooks should move here
+// E.g. _attrModified (which maybe should be split into its per-spec variants)
+
+/**
+ * This SymbolTree is used to build the tree for all Node in a document
+ */
+exports.domSymbolTree = new SymbolTree("DOM SymbolTree");
diff --git a/lib/jsdom/living/helpers/json.js b/lib/jsdom/living/helpers/json.js
new file mode 100644
index 0000000..d1ac3ef
--- /dev/null
+++ b/lib/jsdom/living/helpers/json.js
@@ -0,0 +1,8 @@
+"use strict";
+
+// https://infra.spec.whatwg.org/#parse-json-from-bytes
+exports.parseJSONFromBytes = bytes => {
+  const jsonText = bytes.toString("utf-8");
+
+  return JSON.parse(jsonText);
+};
diff --git a/lib/jsdom/living/helpers/mutation-observers.js b/lib/jsdom/living/helpers/mutation-observers.js
new file mode 100644
index 0000000..196065a
--- /dev/null
+++ b/lib/jsdom/living/helpers/mutation-observers.js
@@ -0,0 +1,196 @@
+"use strict";
+
+const { domSymbolTree } = require("./internal-constants");
+const reportException = require("./runtime-script-errors");
+
+const Event = require("../generated/Event");
+const idlUtils = require("../generated/utils");
+const MutationRecord = require("../generated/MutationRecord");
+
+const MUTATION_TYPE = {
+  ATTRIBUTES: "attributes",
+  CHARACTER_DATA: "characterData",
+  CHILD_LIST: "childList"
+};
+
+// Note:
+// Since jsdom doesn't currently implement the concept of "unit of related similar-origin browsing contexts"
+// (https://html.spec.whatwg.org/multipage/browsers.html#unit-of-related-similar-origin-browsing-contexts)
+// we will approximate that the following properties are global for now.
+
+// https://dom.spec.whatwg.org/#mutation-observer-compound-microtask-queued-flag
+let mutationObserverMicrotaskQueueFlag = false;
+
+// Non-spec compliant: List of all the mutation observers with mutation records enqueued. It's a replacement for
+// mutation observer list (https://dom.spec.whatwg.org/#mutation-observer-list) but without leaking since it's empty
+// before notifying the mutation observers.
+const activeMutationObservers = new Set();
+
+// https://dom.spec.whatwg.org/#signal-slot-list
+const signalSlotList = [];
+
+// https://dom.spec.whatwg.org/#queue-a-mutation-record
+function queueMutationRecord(
+  type,
+  target,
+  name,
+  namespace,
+  oldValue,
+  addedNodes,
+  removedNodes,
+  previousSibling,
+  nextSibling
+) {
+  const interestedObservers = new Map();
+
+  const nodes = domSymbolTree.ancestorsToArray(target);
+
+  for (const node of nodes) {
+    for (const registered of node._registeredObserverList) {
+      const { options, observer: mo } = registered;
+
+      if (
+        !(node !== target && options.subtree === false) &&
+        !(type === MUTATION_TYPE.ATTRIBUTES && options.attributes !== true) &&
+        !(type === MUTATION_TYPE.ATTRIBUTES && options.attributeFilter &&
+          !options.attributeFilter.some(value => value === name || value === namespace)) &&
+        !(type === MUTATION_TYPE.CHARACTER_DATA && options.characterData !== true) &&
+        !(type === MUTATION_TYPE.CHILD_LIST && options.childList === false)
+      ) {
+        if (!interestedObservers.has(mo)) {
+          interestedObservers.set(mo, null);
+        }
+
+        if (
+          (type === MUTATION_TYPE.ATTRIBUTES && options.attributeOldValue === true) ||
+          (type === MUTATION_TYPE.CHARACTER_DATA && options.characterDataOldValue === true)
+        ) {
+          interestedObservers.set(mo, oldValue);
+        }
+      }
+    }
+  }
+
+  for (const [observer, mappedOldValue] of interestedObservers.entries()) {
+    const record = MutationRecord.createImpl(target._globalObject, [], {
+      type,
+      target,
+      attributeName: name,
+      attributeNamespace: namespace,
+      oldValue: mappedOldValue,
+      addedNodes,
+      removedNodes,
+      previousSibling,
+      nextSibling
+    });
+
+    observer._recordQueue.push(record);
+    activeMutationObservers.add(observer);
+  }
+
+  queueMutationObserverMicrotask();
+}
+
+// https://dom.spec.whatwg.org/#queue-a-tree-mutation-record
+function queueTreeMutationRecord(target, addedNodes, removedNodes, previousSibling, nextSibling) {
+  queueMutationRecord(
+    MUTATION_TYPE.CHILD_LIST,
+    target,
+    null,
+    null,
+    null,
+    addedNodes,
+    removedNodes,
+    previousSibling,
+    nextSibling
+  );
+}
+
+// https://dom.spec.whatwg.org/#queue-an-attribute-mutation-record
+function queueAttributeMutationRecord(target, name, namespace, oldValue) {
+  queueMutationRecord(
+    MUTATION_TYPE.ATTRIBUTES,
+    target,
+    name,
+    namespace,
+    oldValue,
+    [],
+    [],
+    null,
+    null
+  );
+}
+
+// https://dom.spec.whatwg.org/#queue-a-mutation-observer-compound-microtask
+function queueMutationObserverMicrotask() {
+  if (mutationObserverMicrotaskQueueFlag) {
+    return;
+  }
+
+  mutationObserverMicrotaskQueueFlag = true;
+
+  Promise.resolve().then(() => {
+    notifyMutationObservers();
+  });
+}
+
+// https://dom.spec.whatwg.org/#notify-mutation-observers
+function notifyMutationObservers() {
+  mutationObserverMicrotaskQueueFlag = false;
+
+  const notifyList = [...activeMutationObservers].sort((a, b) => a._id - b._id);
+  activeMutationObservers.clear();
+
+  const signalList = [...signalSlotList];
+  signalSlotList.splice(0, signalSlotList.length);
+
+  for (const mo of notifyList) {
+    const records = [...mo._recordQueue];
+    mo._recordQueue = [];
+
+    for (const node of mo._nodeList) {
+      node._registeredObserverList = node._registeredObserverList.filter(registeredObserver => {
+        return registeredObserver.source !== mo;
+      });
+
+      if (records.length) {
+        try {
+          mo._callback(
+            records.map(idlUtils.wrapperForImpl),
+            idlUtils.wrapperForImpl(mo)
+          );
+        } catch (e) {
+          const { target } = records[0];
+          const window = target._ownerDocument._defaultView;
+
+          reportException(window, e);
+        }
+      }
+    }
+  }
+
+  for (const slot of signalList) {
+    const slotChangeEvent = Event.createImpl(
+      slot._globalObject,
+      [
+        "slotchange",
+        { bubbles: true }
+      ],
+      { isTrusted: true }
+    );
+
+    slot._dispatch(slotChangeEvent);
+  }
+}
+
+module.exports = {
+  MUTATION_TYPE,
+
+  queueMutationRecord,
+  queueTreeMutationRecord,
+  queueAttributeMutationRecord,
+
+  queueMutationObserverMicrotask,
+
+  signalSlotList
+};
diff --git a/lib/jsdom/living/helpers/namespaces.js b/lib/jsdom/living/helpers/namespaces.js
new file mode 100644
index 0000000..ec8eccc
--- /dev/null
+++ b/lib/jsdom/living/helpers/namespaces.js
@@ -0,0 +1,15 @@
+"use strict";
+
+// https://infra.spec.whatwg.org/#namespaces
+
+exports.HTML_NS = "http://www.w3.org/1999/xhtml";
+
+exports.MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+
+exports.SVG_NS = "http://www.w3.org/2000/svg";
+
+exports.XLINK_NS = "http://www.w3.org/1999/xlink";
+
+exports.XML_NS = "http://www.w3.org/XML/1998/namespace";
+
+exports.XMLNS_NS = "http://www.w3.org/2000/xmlns/";
diff --git a/lib/jsdom/living/helpers/node.js b/lib/jsdom/living/helpers/node.js
new file mode 100644
index 0000000..40e12bc
--- /dev/null
+++ b/lib/jsdom/living/helpers/node.js
@@ -0,0 +1,68 @@
+"use strict";
+
+const NODE_TYPE = require("../node-type");
+const { domSymbolTree } = require("./internal-constants");
+
+// https://dom.spec.whatwg.org/#concept-node-length
+function nodeLength(node) {
+  switch (node.nodeType) {
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+      return 0;
+
+    case NODE_TYPE.TEXT_NODE:
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+    case NODE_TYPE.COMMENT_NODE:
+      return node.data.length;
+
+    default:
+      return domSymbolTree.childrenCount(node);
+  }
+}
+
+// https://dom.spec.whatwg.org/#concept-tree-root
+function nodeRoot(node) {
+  while (domSymbolTree.parent(node)) {
+    node = domSymbolTree.parent(node);
+  }
+
+  return node;
+}
+
+// https://dom.spec.whatwg.org/#concept-tree-inclusive-ancestor
+function isInclusiveAncestor(ancestorNode, node) {
+  while (node) {
+    if (ancestorNode === node) {
+      return true;
+    }
+
+    node = domSymbolTree.parent(node);
+  }
+
+  return false;
+}
+
+// https://dom.spec.whatwg.org/#concept-tree-following
+function isFollowing(nodeA, nodeB) {
+  if (nodeA === nodeB) {
+    return false;
+  }
+
+  let current = nodeB;
+  while (current) {
+    if (current === nodeA) {
+      return true;
+    }
+
+    current = domSymbolTree.following(current);
+  }
+
+  return false;
+}
+
+module.exports = {
+  nodeLength,
+  nodeRoot,
+
+  isInclusiveAncestor,
+  isFollowing
+};
diff --git a/lib/jsdom/living/helpers/number-and-date-inputs.js b/lib/jsdom/living/helpers/number-and-date-inputs.js
new file mode 100644
index 0000000..0d22bf9
--- /dev/null
+++ b/lib/jsdom/living/helpers/number-and-date-inputs.js
@@ -0,0 +1,195 @@
+"use strict";
+const { parseFloatingPointNumber } = require("./strings");
+const {
+  parseDateString,
+  parseLocalDateAndTimeString,
+  parseMonthString,
+  parseTimeString,
+  parseWeekString,
+
+  serializeDate,
+  serializeMonth,
+  serializeNormalizedDateAndTime,
+  serializeTime,
+  serializeWeek,
+  parseDateAsWeek
+} = require("./dates-and-times");
+
+// Necessary because Date.UTC() treats year within [0, 99] as [1900, 1999].
+function getUTCMs(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, millisecond = 0) {
+  if (year > 99 || year < 0) {
+    return Date.UTC(year, month - 1, day, hour, minute, second, millisecond);
+  }
+  const d = new Date(0);
+  d.setUTCFullYear(year);
+  d.setUTCMonth(month - 1);
+  d.setUTCDate(day);
+  d.setUTCHours(hour);
+  d.setUTCMinutes(minute);
+  d.setUTCSeconds(second, millisecond);
+  return d.valueOf();
+}
+
+const dayOfWeekRelMondayLUT = [-1, 0, 1, 2, 3, -3, -2];
+
+exports.convertStringToNumberByType = {
+  // https://html.spec.whatwg.org/multipage/input.html#date-state-(type=date):concept-input-value-string-number
+  date(input) {
+    const date = parseDateString(input);
+    if (date === null) {
+      return null;
+    }
+    return getUTCMs(date.year, date.month, date.day);
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#month-state-(type=month):concept-input-value-string-number
+  month(input) {
+    const date = parseMonthString(input);
+    if (date === null) {
+      return null;
+    }
+    return (date.year - 1970) * 12 + (date.month - 1);
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#week-state-(type=week):concept-input-value-string-number
+  week(input) {
+    const date = parseWeekString(input);
+    if (date === null) {
+      return null;
+    }
+    const dateObj = new Date(getUTCMs(date.year));
+    // An HTML week starts on Monday, while 0 represents Sunday. Account for such.
+    const dayOfWeekRelMonday = dayOfWeekRelMondayLUT[dateObj.getUTCDay()];
+    return dateObj.setUTCDate(1 + 7 * (date.week - 1) - dayOfWeekRelMonday);
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#time-state-(type=time):concept-input-value-string-number
+  time(input) {
+    const time = parseTimeString(input);
+    if (time === null) {
+      return null;
+    }
+    return ((time.hour * 60 + time.minute) * 60 + time.second) * 1000 + time.millisecond;
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type=datetime-local):concept-input-value-string-number
+  "datetime-local"(input) {
+    const dateAndTime = parseLocalDateAndTimeString(input);
+    if (dateAndTime === null) {
+      return null;
+    }
+    const { date: { year, month, day }, time: { hour, minute, second, millisecond } } = dateAndTime;
+    // Doesn't quite matter whether or not UTC is used, since the offset from 1970-01-01 local time is returned.
+    return getUTCMs(year, month, day, hour, minute, second, millisecond);
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#number-state-(type=number):concept-input-value-string-number
+  number: parseFloatingPointNumber,
+  // https://html.spec.whatwg.org/multipage/input.html#range-state-(type=range):concept-input-value-string-number
+  range: parseFloatingPointNumber
+};
+
+exports.convertStringToDateByType = {
+  date(input) {
+    const parsedInput = exports.convertStringToNumberByType.date(input);
+    return parsedInput === null ? null : new Date(parsedInput);
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#month-state-(type=month):concept-input-value-string-number
+  month(input) {
+    const parsedMonthString = parseMonthString(input);
+    if (parsedMonthString === null) {
+      return null;
+    }
+
+    const date = new Date(0);
+    date.setUTCFullYear(parsedMonthString.year);
+    date.setUTCMonth(parsedMonthString.month - 1);
+    return date;
+  },
+  week(input) {
+    const parsedInput = exports.convertStringToNumberByType.week(input);
+    return parsedInput === null ? null : new Date(parsedInput);
+  },
+  time(input) {
+    const parsedInput = exports.convertStringToNumberByType.time(input);
+    return parsedInput === null ? null : new Date(parsedInput);
+  },
+  "datetime-local"(input) {
+    const parsedInput = exports.convertStringToNumberByType["datetime-local"](input);
+    return parsedInput === null ? null : new Date(parsedInput);
+  }
+};
+
+exports.serializeDateByType = {
+  date(input) {
+    return serializeDate({
+      year: input.getUTCFullYear(),
+      month: input.getUTCMonth() + 1,
+      day: input.getUTCDate()
+    });
+  },
+  month(input) {
+    return serializeMonth({
+      year: input.getUTCFullYear(),
+      month: input.getUTCMonth() + 1
+    });
+  },
+  week(input) {
+    return serializeWeek(parseDateAsWeek(input));
+  },
+  time(input) {
+    return serializeTime({
+      hour: input.getUTCHours(),
+      minute: input.getUTCMinutes(),
+      second: input.getUTCSeconds(),
+      millisecond: input.getUTCMilliseconds()
+    });
+  },
+  "datetime-local"(input) {
+    return serializeNormalizedDateAndTime({
+      date: {
+        year: input.getUTCFullYear(),
+        month: input.getUTCMonth() + 1,
+        day: input.getUTCDate()
+      },
+      time: {
+        hour: input.getUTCHours(),
+        minute: input.getUTCMinutes(),
+        second: input.getUTCSeconds(),
+        millisecond: input.getUTCMilliseconds()
+      }
+    });
+  }
+};
+
+exports.convertNumberToStringByType = {
+  // https://html.spec.whatwg.org/multipage/input.html#date-state-(type=date):concept-input-value-string-number
+  date(input) {
+    return exports.serializeDateByType.date(new Date(input));
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#month-state-(type=month):concept-input-value-string-date
+  month(input) {
+    const year = 1970 + Math.floor(input / 12);
+    const month = input % 12;
+    const date = new Date();
+    date.setUTCFullYear(year);
+    date.setUTCMonth(month);
+
+    return exports.serializeDateByType.month(date);
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#week-state-(type=week):concept-input-value-string-date
+  week(input) {
+    return exports.serializeDateByType.week(new Date(input));
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#time-state-(type=time):concept-input-value-string-date
+  time(input) {
+    return exports.serializeDateByType.time(new Date(input));
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type=datetime-local):concept-input-value-number-string
+  "datetime-local"(input) {
+    return exports.serializeDateByType["datetime-local"](new Date(input));
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#number-state-(type=number):concept-input-value-number-string
+  number(input) {
+    return input.toString();
+  },
+  // https://html.spec.whatwg.org/multipage/input.html#range-state-(type=range):concept-input-value-number-string
+  range(input) {
+    return input.toString();
+  }
+};
diff --git a/lib/jsdom/living/helpers/ordered-set.js b/lib/jsdom/living/helpers/ordered-set.js
new file mode 100644
index 0000000..d3e1932
--- /dev/null
+++ b/lib/jsdom/living/helpers/ordered-set.js
@@ -0,0 +1,104 @@
+"use strict";
+
+// https://infra.spec.whatwg.org/#sets
+//
+// Only use this class if a Set cannot be used, e.g. when "replace" operation is needed, since there's no way to replace
+// an element while keep the relative order using a Set, only remove and then add something at the end.
+
+module.exports = class OrderedSet {
+  constructor() {
+    this._items = [];
+  }
+
+  append(item) {
+    if (!this.contains(item)) {
+      this._items.push(item);
+    }
+  }
+
+  prepend(item) {
+    if (!this.contains(item)) {
+      this._items.unshift(item);
+    }
+  }
+
+  replace(item, replacement) {
+    let seen = false;
+    for (let i = 0; i < this._items.length;) {
+      const isInstance = this._items[i] === item || this._items[i] === replacement;
+      if (seen && isInstance) {
+        this._items.splice(i, 1);
+      } else {
+        if (isInstance) {
+          this._items[i] = replacement;
+          seen = true;
+        }
+        i++;
+      }
+    }
+  }
+
+  remove(...items) {
+    this.removePredicate(item => items.includes(item));
+  }
+
+  removePredicate(predicate) {
+    for (let i = 0; i < this._items.length;) {
+      if (predicate(this._items[i])) {
+        this._items.splice(i, 1);
+      } else {
+        i++;
+      }
+    }
+  }
+
+  empty() {
+    this._items.length = 0;
+  }
+
+  contains(item) {
+    return this._items.includes(item);
+  }
+
+  get size() {
+    return this._items.length;
+  }
+
+  isEmpty() {
+    return this._items.length === 0;
+  }
+
+  // Useful for other parts of jsdom
+
+  [Symbol.iterator]() {
+    return this._items[Symbol.iterator]();
+  }
+
+  keys() {
+    return this._items.keys();
+  }
+
+  get(index) {
+    return this._items[index];
+  }
+
+  some(func) {
+    return this._items.some(func);
+  }
+
+  // https://dom.spec.whatwg.org/#concept-ordered-set-parser
+  static parse(input) {
+    const tokens = new OrderedSet();
+    for (const token of input.split(/[\t\n\f\r ]+/)) {
+      if (token) {
+        tokens.append(token);
+      }
+    }
+    return tokens;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-ordered-set-serializer
+  serialize() {
+    return this._items.join(" ");
+  }
+};
diff --git a/lib/jsdom/living/helpers/runtime-script-errors.js b/lib/jsdom/living/helpers/runtime-script-errors.js
new file mode 100644
index 0000000..24a35bf
--- /dev/null
+++ b/lib/jsdom/living/helpers/runtime-script-errors.js
@@ -0,0 +1,72 @@
+"use strict";
+const util = require("util");
+const idlUtils = require("../generated/utils");
+const ErrorEvent = require("../generated/ErrorEvent");
+const { createAnEvent } = require("./events");
+
+const errorReportingMode = Symbol("error reporting mode");
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#report-the-error
+// Omits script parameter and any check for muted errors.
+// Takes target as an EventTarget impl.
+// Takes error object, message, and location as params, unlike the spec.
+// Returns whether the event was handled or not.
+function reportAnError(line, col, target, errorObject, message, location) {
+  if (target[errorReportingMode]) {
+    return false;
+  }
+
+  target[errorReportingMode] = true;
+
+  const event = createAnEvent("error", target._globalObject, ErrorEvent, {
+    cancelable: true,
+    message,
+    filename: location,
+    lineno: line,
+    colno: col,
+    error: errorObject
+  });
+
+  try {
+    target._dispatch(event);
+  } finally {
+    target[errorReportingMode] = false;
+    return event.defaultPrevented;
+  }
+}
+
+module.exports = function reportException(window, error, filenameHint) {
+  // This function will give good results on real Error objects with stacks; poor ones otherwise
+
+  const stack = error && error.stack;
+  const lines = stack && stack.split("\n");
+
+  // Find the first line that matches; important for multi-line messages
+  let pieces;
+  if (lines) {
+    for (let i = 1; i < lines.length && !pieces; ++i) {
+      pieces = lines[i].match(/at (?:(.+)\s+)?\(?(?:(.+?):(\d+):(\d+)|([^)]+))\)?/);
+    }
+  }
+
+  const fileName = (pieces && pieces[2]) || filenameHint || window._document.URL;
+  const lineNumber = (pieces && parseInt(pieces[3])) || 0;
+  const columnNumber = (pieces && parseInt(pieces[4])) || 0;
+
+  const windowImpl = idlUtils.implForWrapper(window);
+
+  const handled = reportAnError(lineNumber, columnNumber, windowImpl, error, error.message, fileName);
+
+  if (!handled) {
+    const errorString = shouldBeDisplayedAsError(error) ? `[${error.name}: ${error.message}]` : util.inspect(error);
+    const jsdomError = new Error(`Uncaught ${errorString}`);
+    jsdomError.detail = error;
+    jsdomError.type = "unhandled exception";
+
+    window._virtualConsole.emit("jsdomError", jsdomError);
+  }
+};
+
+function shouldBeDisplayedAsError(x) {
+  return x.name && x.message !== undefined && x.stack;
+}
diff --git a/lib/jsdom/living/helpers/selectors.js b/lib/jsdom/living/helpers/selectors.js
new file mode 100644
index 0000000..8f320ab
--- /dev/null
+++ b/lib/jsdom/living/helpers/selectors.js
@@ -0,0 +1,47 @@
+"use strict";
+
+const nwsapi = require("nwsapi");
+
+const idlUtils = require("../generated/utils");
+
+function initNwsapi(node) {
+  const { _globalObject, _ownerDocument } = node;
+
+  return nwsapi({
+    document: _ownerDocument,
+    DOMException: _globalObject.DOMException
+  });
+}
+
+exports.matchesDontThrow = (elImpl, selector) => {
+  const document = elImpl._ownerDocument;
+
+  if (!document._nwsapiDontThrow) {
+    document._nwsapiDontThrow = initNwsapi(elImpl);
+    document._nwsapiDontThrow.configure({
+      LOGERRORS: false,
+      VERBOSITY: false,
+      IDS_DUPES: true,
+      MIXEDCASE: true
+    });
+  }
+
+  return document._nwsapiDontThrow.match(selector, idlUtils.wrapperForImpl(elImpl));
+};
+
+// nwsapi gets `document.documentElement` at creation-time, so we have to initialize lazily, since in the initial
+// stages of Document initialization, there is no documentElement present yet.
+exports.addNwsapi = parentNode => {
+  const document = parentNode._ownerDocument;
+
+  if (!document._nwsapi) {
+    document._nwsapi = initNwsapi(parentNode);
+    document._nwsapi.configure({
+      LOGERRORS: false,
+      IDS_DUPES: true,
+      MIXEDCASE: true
+    });
+  }
+
+  return document._nwsapi;
+};
diff --git a/lib/jsdom/living/helpers/shadow-dom.js b/lib/jsdom/living/helpers/shadow-dom.js
new file mode 100644
index 0000000..a88a33e
--- /dev/null
+++ b/lib/jsdom/living/helpers/shadow-dom.js
@@ -0,0 +1,285 @@
+"use strict";
+
+const NODE_TYPE = require("../node-type");
+
+const { nodeRoot } = require("./node");
+const { HTML_NS } = require("./namespaces");
+const { domSymbolTree } = require("./internal-constants");
+const { signalSlotList, queueMutationObserverMicrotask } = require("./mutation-observers");
+
+// Valid host element for ShadowRoot.
+// Defined in: https://dom.spec.whatwg.org/#dom-element-attachshadow
+const VALID_HOST_ELEMENT_NAME = new Set([
+  "article",
+  "aside",
+  "blockquote",
+  "body",
+  "div",
+  "footer",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "main",
+  "nav",
+  "p",
+  "section",
+  "span"
+]);
+
+function isValidHostElementName(name) {
+  return VALID_HOST_ELEMENT_NAME.has(name);
+}
+
+// Use an approximation by checking the presence of nodeType instead of instead of using the isImpl from
+// "../generated/Node" to avoid introduction of circular dependencies.
+function isNode(nodeImpl) {
+  return Boolean(nodeImpl && "nodeType" in nodeImpl);
+}
+
+// Use an approximation by checking the value of nodeType and presence of nodeType host instead of instead
+// of using the isImpl from "../generated/ShadowRoot" to avoid introduction of circular dependencies.
+function isShadowRoot(nodeImpl) {
+  return Boolean(nodeImpl && nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE && "host" in nodeImpl);
+}
+
+// https://dom.spec.whatwg.org/#concept-slotable
+function isSlotable(nodeImpl) {
+  return nodeImpl && (nodeImpl.nodeType === NODE_TYPE.ELEMENT_NODE || nodeImpl.nodeType === NODE_TYPE.TEXT_NODE);
+}
+
+function isSlot(nodeImpl) {
+  return nodeImpl && nodeImpl.localName === "slot" && nodeImpl._namespaceURI === HTML_NS;
+}
+
+// https://dom.spec.whatwg.org/#concept-shadow-including-inclusive-ancestor
+function isShadowInclusiveAncestor(ancestor, node) {
+  while (isNode(node)) {
+    if (node === ancestor) {
+      return true;
+    }
+
+    if (isShadowRoot(node)) {
+      node = node.host;
+    } else {
+      node = domSymbolTree.parent(node);
+    }
+  }
+
+  return false;
+}
+
+// https://dom.spec.whatwg.org/#retarget
+function retarget(a, b) {
+  while (true) {
+    if (!isNode(a)) {
+      return a;
+    }
+
+    const aRoot = nodeRoot(a);
+    if (
+      !isShadowRoot(aRoot) ||
+      (isNode(b) && isShadowInclusiveAncestor(aRoot, b))
+    ) {
+      return a;
+    }
+
+    a = nodeRoot(a).host;
+  }
+}
+
+// https://dom.spec.whatwg.org/#get-the-parent
+function getEventTargetParent(eventTarget, event) {
+  // _getTheParent will be missing for Window, since it doesn't have an impl class and we don't want to pollute the
+  // user-visible global scope with a _getTheParent value. TODO: remove this entire function and use _getTheParent
+  // directly, once Window gets split into impl/wrapper.
+  return eventTarget._getTheParent ? eventTarget._getTheParent(event) : null;
+}
+
+// https://dom.spec.whatwg.org/#concept-shadow-including-root
+function shadowIncludingRoot(node) {
+  const root = nodeRoot(node);
+  return isShadowRoot(root) ? shadowIncludingRoot(root.host) : root;
+}
+
+// https://dom.spec.whatwg.org/#assign-a-slot
+function assignSlot(slotable) {
+  const slot = findSlot(slotable);
+
+  if (slot) {
+    assignSlotable(slot);
+  }
+}
+
+// https://dom.spec.whatwg.org/#assign-slotables
+function assignSlotable(slot) {
+  const slotables = findSlotable(slot);
+
+  let shouldFireSlotChange = false;
+
+  if (slotables.length !== slot._assignedNodes.length) {
+    shouldFireSlotChange = true;
+  } else {
+    for (let i = 0; i < slotables.length; i++) {
+      if (slotables[i] !== slot._assignedNodes[i]) {
+        shouldFireSlotChange = true;
+        break;
+      }
+    }
+  }
+
+  if (shouldFireSlotChange) {
+    signalSlotChange(slot);
+  }
+
+  slot._assignedNodes = slotables;
+
+  for (const slotable of slotables) {
+    slotable._assignedSlot = slot;
+  }
+}
+
+// https://dom.spec.whatwg.org/#assign-slotables-for-a-tree
+function assignSlotableForTree(root) {
+  for (const slot of domSymbolTree.treeIterator(root)) {
+    if (isSlot(slot)) {
+      assignSlotable(slot);
+    }
+  }
+}
+
+// https://dom.spec.whatwg.org/#find-slotables
+function findSlotable(slot) {
+  const result = [];
+
+  const root = nodeRoot(slot);
+  if (!isShadowRoot(root)) {
+    return result;
+  }
+
+  for (const slotable of domSymbolTree.treeIterator(root.host)) {
+    const foundSlot = findSlot(slotable);
+
+    if (foundSlot === slot) {
+      result.push(slotable);
+    }
+  }
+
+  return result;
+}
+
+// https://dom.spec.whatwg.org/#find-flattened-slotables
+function findFlattenedSlotables(slot) {
+  const result = [];
+
+  const root = nodeRoot(slot);
+  if (!isShadowRoot(root)) {
+    return result;
+  }
+
+  const slotables = findSlotable(slot);
+
+  if (slotables.length === 0) {
+    for (const child of domSymbolTree.childrenIterator(slot)) {
+      if (isSlotable(child)) {
+        slotables.push(child);
+      }
+    }
+  }
+
+  for (const node of slotables) {
+    if (isSlot(node) && isShadowRoot(nodeRoot(node))) {
+      const temporaryResult = findFlattenedSlotables(node);
+      result.push(...temporaryResult);
+    } else {
+      result.push(node);
+    }
+  }
+
+  return result;
+}
+
+// https://dom.spec.whatwg.org/#find-a-slot
+function findSlot(slotable, openFlag) {
+  const { parentNode: parent } = slotable;
+
+  if (!parent) {
+    return null;
+  }
+
+  const shadow = parent._shadowRoot;
+
+  if (!shadow || (openFlag && shadow.mode !== "open")) {
+    return null;
+  }
+
+  for (const child of domSymbolTree.treeIterator(shadow)) {
+    if (isSlot(child) && child.name === slotable._slotableName) {
+      return child;
+    }
+  }
+
+  return null;
+}
+
+// https://dom.spec.whatwg.org/#signal-a-slot-change
+function signalSlotChange(slot) {
+  if (!signalSlotList.some(entry => entry === slot)) {
+    signalSlotList.push(slot);
+  }
+
+  queueMutationObserverMicrotask();
+}
+
+// https://dom.spec.whatwg.org/#concept-shadow-including-descendant
+function* shadowIncludingInclusiveDescendantsIterator(node) {
+  yield node;
+
+  if (node._shadowRoot) {
+    yield* shadowIncludingInclusiveDescendantsIterator(node._shadowRoot);
+  }
+
+  for (const child of domSymbolTree.childrenIterator(node)) {
+    yield* shadowIncludingInclusiveDescendantsIterator(child);
+  }
+}
+
+// https://dom.spec.whatwg.org/#concept-shadow-including-descendant
+function* shadowIncludingDescendantsIterator(node) {
+  if (node._shadowRoot) {
+    yield* shadowIncludingInclusiveDescendantsIterator(node._shadowRoot);
+  }
+
+  for (const child of domSymbolTree.childrenIterator(node)) {
+    yield* shadowIncludingInclusiveDescendantsIterator(child);
+  }
+}
+
+module.exports = {
+  isValidHostElementName,
+
+  isNode,
+  isSlotable,
+  isSlot,
+  isShadowRoot,
+
+  isShadowInclusiveAncestor,
+  retarget,
+  getEventTargetParent,
+  shadowIncludingRoot,
+
+  assignSlot,
+  assignSlotable,
+  assignSlotableForTree,
+
+  findSlot,
+  findFlattenedSlotables,
+
+  signalSlotChange,
+
+  shadowIncludingInclusiveDescendantsIterator,
+  shadowIncludingDescendantsIterator
+};
diff --git a/lib/jsdom/living/helpers/strings.js b/lib/jsdom/living/helpers/strings.js
new file mode 100644
index 0000000..1579251
--- /dev/null
+++ b/lib/jsdom/living/helpers/strings.js
@@ -0,0 +1,148 @@
+"use strict";
+
+// https://infra.spec.whatwg.org/#ascii-whitespace
+const asciiWhitespaceRe = /^[\t\n\f\r ]$/;
+exports.asciiWhitespaceRe = asciiWhitespaceRe;
+
+// https://infra.spec.whatwg.org/#ascii-lowercase
+exports.asciiLowercase = s => {
+  return s.replace(/[A-Z]/g, l => l.toLowerCase());
+};
+
+// https://infra.spec.whatwg.org/#ascii-uppercase
+exports.asciiUppercase = s => {
+  return s.replace(/[a-z]/g, l => l.toUpperCase());
+};
+
+// https://infra.spec.whatwg.org/#strip-newlines
+exports.stripNewlines = s => {
+  return s.replace(/[\n\r]+/g, "");
+};
+
+// https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
+exports.stripLeadingAndTrailingASCIIWhitespace = s => {
+  return s.replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
+};
+
+// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+exports.stripAndCollapseASCIIWhitespace = s => {
+  return s.replace(/[ \t\n\f\r]+/g, " ").replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
+};
+
+// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-simple-colour
+exports.isValidSimpleColor = s => {
+  return /^#[a-fA-F\d]{6}$/.test(s);
+};
+
+// https://infra.spec.whatwg.org/#ascii-case-insensitive
+exports.asciiCaseInsensitiveMatch = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a.length; ++i) {
+    if ((a.charCodeAt(i) | 32) !== (b.charCodeAt(i) | 32)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-integers
+// Error is represented as null.
+const parseInteger = exports.parseInteger = input => {
+  // The implementation here is slightly different from the spec's. We want to use parseInt(), but parseInt() trims
+  // Unicode whitespace in addition to just ASCII ones, so we make sure that the trimmed prefix contains only ASCII
+  // whitespace ourselves.
+  const numWhitespace = input.length - input.trimStart().length;
+  if (/[^\t\n\f\r ]/.test(input.slice(0, numWhitespace))) {
+    return null;
+  }
+  // We don't allow hexadecimal numbers here.
+  // eslint-disable-next-line radix
+  const value = parseInt(input, 10);
+  if (Number.isNaN(value)) {
+    return null;
+  }
+  // parseInt() returns -0 for "-0". Normalize that here.
+  return value === 0 ? 0 : value;
+};
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-non-negative-integers
+// Error is represented as null.
+exports.parseNonNegativeInteger = input => {
+  const value = parseInteger(input);
+  if (value === null) {
+    return null;
+  }
+  if (value < 0) {
+    return null;
+  }
+  return value;
+};
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-floating-point-number
+const floatingPointNumRe = /^-?(?:\d+|\d*\.\d+)(?:[eE][-+]?\d+)?$/;
+exports.isValidFloatingPointNumber = str => floatingPointNumRe.test(str);
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-floating-point-number-values
+// Error is represented as null.
+exports.parseFloatingPointNumber = str => {
+  // The implementation here is slightly different from the spec's. We need to use parseFloat() in order to retain
+  // accuracy, but parseFloat() trims Unicode whitespace in addition to just ASCII ones, so we make sure that the
+  // trimmed prefix contains only ASCII whitespace ourselves.
+  const numWhitespace = str.length - str.trimStart().length;
+  if (/[^\t\n\f\r ]/.test(str.slice(0, numWhitespace))) {
+    return null;
+  }
+  const parsed = parseFloat(str);
+  return isFinite(parsed) ? parsed : null;
+};
+
+// https://infra.spec.whatwg.org/#split-on-ascii-whitespace
+exports.splitOnASCIIWhitespace = str => {
+  let position = 0;
+  const tokens = [];
+  while (position < str.length && asciiWhitespaceRe.test(str[position])) {
+    position++;
+  }
+  if (position === str.length) {
+    return tokens;
+  }
+  while (position < str.length) {
+    const start = position;
+    while (position < str.length && !asciiWhitespaceRe.test(str[position])) {
+      position++;
+    }
+    tokens.push(str.slice(start, position));
+    while (position < str.length && asciiWhitespaceRe.test(str[position])) {
+      position++;
+    }
+  }
+  return tokens;
+};
+
+// https://infra.spec.whatwg.org/#split-on-commas
+exports.splitOnCommas = str => {
+  let position = 0;
+  const tokens = [];
+  while (position < str.length) {
+    let start = position;
+    while (position < str.length && str[position] !== ",") {
+      position++;
+    }
+    let end = position;
+    while (start < str.length && asciiWhitespaceRe.test(str[start])) {
+      start++;
+    }
+    while (end > start && asciiWhitespaceRe.test(str[end - 1])) {
+      end--;
+    }
+    tokens.push(str.slice(start, end));
+    if (position < str.length) {
+      position++;
+    }
+  }
+  return tokens;
+};
diff --git a/lib/jsdom/living/helpers/style-rules.js b/lib/jsdom/living/helpers/style-rules.js
new file mode 100644
index 0000000..1bfa372
--- /dev/null
+++ b/lib/jsdom/living/helpers/style-rules.js
@@ -0,0 +1,103 @@
+"use strict";
+const cssom = require("cssom");
+const defaultStyleSheet = require("../../browser/default-stylesheet");
+const { matchesDontThrow } = require("./selectors");
+
+const { forEach, indexOf } = Array.prototype;
+
+let parsedDefaultStyleSheet;
+
+// Properties for which getResolvedValue is implemented. This is less than
+// every supported property.
+// https://drafts.csswg.org/indexes/#properties
+exports.propertiesWithResolvedValueImplemented = {
+  __proto__: null,
+
+  // https://drafts.csswg.org/css2/visufx.html#visibility
+  visibility: {
+    inherited: true,
+    initial: "visible",
+    computedValue: "as-specified"
+  }
+};
+
+exports.forEachMatchingSheetRuleOfElement = (element, handleRule) => {
+  function handleSheet(sheet) {
+    forEach.call(sheet.cssRules, rule => {
+      if (rule.media) {
+        if (indexOf.call(rule.media, "screen") !== -1) {
+          forEach.call(rule.cssRules, innerRule => {
+            if (matches(innerRule, element)) {
+              handleRule(innerRule);
+            }
+          });
+        }
+      } else if (matches(rule, element)) {
+        handleRule(rule);
+      }
+    });
+  }
+
+  if (!parsedDefaultStyleSheet) {
+    parsedDefaultStyleSheet = cssom.parse(defaultStyleSheet);
+  }
+
+  handleSheet(parsedDefaultStyleSheet);
+  forEach.call(element.ownerDocument.styleSheets, handleSheet);
+};
+
+function matches(rule, element) {
+  return matchesDontThrow(element, rule.selectorText);
+}
+
+// Naive implementation of https://drafts.csswg.org/css-cascade-4/#cascading
+// based on the previous jsdom implementation of getComputedStyle.
+// Does not implement https://drafts.csswg.org/css-cascade-4/#cascade-specificity,
+// or rather specificity is only implemented by the order in which the matching
+// rules appear. The last rule is the most specific while the first rule is
+// the least specific.
+function getCascadedPropertyValue(element, property) {
+  let value = "";
+
+  exports.forEachMatchingSheetRuleOfElement(element, rule => {
+    value = rule.style.getPropertyValue(property);
+  });
+
+  return value;
+}
+
+// https://drafts.csswg.org/css-cascade-4/#specified-value
+function getSpecifiedValue(element, property) {
+  const cascade = getCascadedPropertyValue(element, property);
+
+  if (cascade !== "") {
+    return cascade;
+  }
+
+  // Defaulting
+  const { initial, inherited } = exports.propertiesWithResolvedValueImplemented[property];
+  if (inherited && element.parentElement !== null) {
+    return getComputedValue(element.parentElement, property);
+  }
+
+  // root element without parent element or inherited property
+  return initial;
+}
+
+// https://drafts.csswg.org/css-cascade-4/#computed-value
+function getComputedValue(element, property) {
+  const { computedValue } = exports.propertiesWithResolvedValueImplemented[property];
+  if (computedValue === "as-specified") {
+    return getSpecifiedValue(element, property);
+  }
+
+  throw new TypeError(`Internal error: unrecognized computed value instruction '${computedValue}'`);
+}
+
+// https://drafts.csswg.org/cssom/#resolved-value
+// Only implements `visibility`
+exports.getResolvedValue = (element, property) => {
+  // Determined for special case properties, none of which are implemented here.
+  // So we skip to "any other property: The resolved value is the computed value."
+  return getComputedValue(element, property);
+};
diff --git a/lib/jsdom/living/helpers/stylesheets.js b/lib/jsdom/living/helpers/stylesheets.js
new file mode 100644
index 0000000..bf82d14
--- /dev/null
+++ b/lib/jsdom/living/helpers/stylesheets.js
@@ -0,0 +1,113 @@
+"use strict";
+const cssom = require("cssom");
+const whatwgEncoding = require("whatwg-encoding");
+const whatwgURL = require("whatwg-url");
+
+// TODO: this should really implement https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
+// It (and the things it calls) is nowhere close right now.
+exports.fetchStylesheet = (elementImpl, urlString) => {
+  const parsedURL = whatwgURL.parseURL(urlString);
+  return fetchStylesheetInternal(elementImpl, urlString, parsedURL);
+};
+
+// https://drafts.csswg.org/cssom/#remove-a-css-style-sheet
+exports.removeStylesheet = (sheet, elementImpl) => {
+  const { styleSheets } = elementImpl._ownerDocument;
+  styleSheets.splice(styleSheets.indexOf(sheet, 1));
+
+  // Remove the association explicitly; in the spec it's implicit so this step doesn't exist.
+  elementImpl.sheet = null;
+
+  // TODO: "Set the CSS style sheet’s parent CSS style sheet, owner node and owner CSS rule to null."
+  // Probably when we have a real CSSOM implementation.
+};
+
+// https://drafts.csswg.org/cssom/#create-a-css-style-sheet kinda:
+// - Parsing failures are not handled gracefully like they should be
+// - The import rules stuff seems out of place, and probably should affect the load event...
+exports.createStylesheet = (sheetText, elementImpl, baseURL) => {
+  let sheet;
+  try {
+    sheet = cssom.parse(sheetText);
+  } catch (e) {
+    if (elementImpl._ownerDocument._defaultView) {
+      const error = new Error("Could not parse CSS stylesheet");
+      error.detail = sheetText;
+      error.type = "css parsing";
+
+      elementImpl._ownerDocument._defaultView._virtualConsole.emit("jsdomError", error);
+    }
+    return;
+  }
+
+  scanForImportRules(elementImpl, sheet.cssRules, baseURL);
+
+  addStylesheet(sheet, elementImpl);
+};
+
+// https://drafts.csswg.org/cssom/#add-a-css-style-sheet
+function addStylesheet(sheet, elementImpl) {
+  elementImpl._ownerDocument.styleSheets.push(sheet);
+
+  // Set the association explicitly; in the spec it's implicit.
+  elementImpl.sheet = sheet;
+
+  // TODO: title and disabled stuff
+}
+
+function fetchStylesheetInternal(elementImpl, urlString, parsedURL) {
+  const document = elementImpl._ownerDocument;
+  let defaultEncoding = document._encoding;
+  const resourceLoader = document._resourceLoader;
+
+  if (elementImpl.localName === "link" && elementImpl.hasAttributeNS(null, "charset")) {
+    defaultEncoding = whatwgEncoding.labelToName(elementImpl.getAttributeNS(null, "charset"));
+  }
+
+  function onStylesheetLoad(data) {
+    const css = whatwgEncoding.decode(data, defaultEncoding);
+
+    // TODO: MIME type checking?
+    if (elementImpl.sheet) {
+      exports.removeStylesheet(elementImpl.sheet, elementImpl);
+    }
+    exports.createStylesheet(css, elementImpl, parsedURL);
+  }
+
+  resourceLoader.fetch(urlString, {
+    element: elementImpl,
+    onLoad: onStylesheetLoad
+  });
+}
+
+// TODO this is actually really messed up and overwrites the sheet on elementImpl
+// Tracking in https://github.com/jsdom/jsdom/issues/2124
+function scanForImportRules(elementImpl, cssRules, baseURL) {
+  if (!cssRules) {
+    return;
+  }
+
+  for (let i = 0; i < cssRules.length; ++i) {
+    if (cssRules[i].cssRules) {
+      // @media rule: keep searching inside it.
+      scanForImportRules(elementImpl, cssRules[i].cssRules, baseURL);
+    } else if (cssRules[i].href) {
+      // @import rule: fetch the resource and evaluate it.
+      // See http://dev.w3.org/csswg/cssom/#css-import-rule
+      //     If loading of the style sheet fails its cssRules list is simply
+      //     empty. I.e. an @import rule always has an associated style sheet.
+      const parsed = whatwgURL.parseURL(cssRules[i].href, { baseURL });
+      if (parsed === null) {
+        const window = elementImpl._ownerDocument._defaultView;
+        if (window) {
+          const error = new Error(`Could not parse CSS @import URL ${cssRules[i].href} relative to base URL ` +
+                                  `"${whatwgURL.serializeURL(baseURL)}"`);
+          error.type = "css @import URL parsing";
+          window._virtualConsole.emit("jsdomError", error);
+        }
+      } else {
+        fetchStylesheetInternal(elementImpl, whatwgURL.serializeURL(parsed), parsed);
+      }
+    }
+  }
+}
diff --git a/lib/jsdom/living/helpers/svg/basic-types.js b/lib/jsdom/living/helpers/svg/basic-types.js
new file mode 100644
index 0000000..16d0dc1
--- /dev/null
+++ b/lib/jsdom/living/helpers/svg/basic-types.js
@@ -0,0 +1,41 @@
+"use strict";
+
+// https://svgwg.org/svg2-draft/types.html#TermDetach
+function detach(value) {
+  if (typeof value === "string") {
+    return;
+  }
+
+  throw new TypeError(`jsdom internal error: detaching object of wrong type ${value}`);
+}
+exports.detach = detach;
+
+// https://svgwg.org/svg2-draft/types.html#TermAttach
+// listObject corresponds to the parameter taken by the algorithm in the spec, but is currently unused because only
+// DOMString type is supported by jsdom (and this function) right now.
+// eslint-disable-next-line no-unused-vars
+function attach(value, listObject) {
+  if (typeof value === "string") {
+    return;
+  }
+
+  throw new TypeError(`jsdom internal error: attaching object of wrong type ${value}`);
+}
+exports.attach = attach;
+
+// https://svgwg.org/svg2-draft/types.html#TermReserialize for DOMString.
+function reserializeSpaceSeparatedTokens(elements) {
+  return elements.join(" ");
+}
+exports.reserializeSpaceSeparatedTokens = reserializeSpaceSeparatedTokens;
+
+// Used for systemLanguage attribute, whose value is a set of comma-separated tokens:
+// https://svgwg.org/svg2-draft/struct.html#SystemLanguageAttribute
+// SVG 2 spec (https://svgwg.org/svg2-draft/types.html#TermReserialize) says any SVGStringList should reserialize the
+// same way, as space-separated tokens, but doing so for systemLanguage is illogical and contradicts the Firefox
+// behavior.
+// I cannot find a description of reserialization of SVGStringList in the SVG 1.1 spec.
+function reserializeCommaSeparatedTokens(elements) {
+  return elements.join(", ");
+}
+exports.reserializeCommaSeparatedTokens = reserializeCommaSeparatedTokens;
diff --git a/lib/jsdom/living/helpers/text.js b/lib/jsdom/living/helpers/text.js
new file mode 100644
index 0000000..632c0e5
--- /dev/null
+++ b/lib/jsdom/living/helpers/text.js
@@ -0,0 +1,19 @@
+"use strict";
+const { domSymbolTree } = require("./internal-constants");
+const { CDATA_SECTION_NODE, TEXT_NODE } = require("../node-type");
+
+//
+// https://dom.spec.whatwg.org/#concept-child-text-content
+//
+exports.childTextContent = node => {
+  let result = "";
+  const iterator = domSymbolTree.childrenIterator(node);
+  for (const child of iterator) {
+    if (child.nodeType === TEXT_NODE ||
+        // The CDataSection extends Text.
+        child.nodeType === CDATA_SECTION_NODE) {
+      result += child.data;
+    }
+  }
+  return result;
+};
diff --git a/lib/jsdom/living/helpers/traversal.js b/lib/jsdom/living/helpers/traversal.js
new file mode 100644
index 0000000..91f7148
--- /dev/null
+++ b/lib/jsdom/living/helpers/traversal.js
@@ -0,0 +1,72 @@
+"use strict";
+const { domSymbolTree } = require("./internal-constants");
+const { HTML_NS } = require("./namespaces");
+
+// All these operate on and return impls, not wrappers!
+
+exports.closest = (e, localName, namespace = HTML_NS) => {
+  while (e) {
+    if (e.localName === localName && e.namespaceURI === namespace) {
+      return e;
+    }
+    e = domSymbolTree.parent(e);
+  }
+
+  return null;
+};
+
+exports.childrenByLocalName = (parent, localName, namespace = HTML_NS) => {
+  return domSymbolTree.childrenToArray(parent, { filter(node) {
+    return node._localName === localName && node._namespaceURI === namespace;
+  } });
+};
+
+exports.descendantsByLocalName = (parent, localName, namespace = HTML_NS) => {
+  return domSymbolTree.treeToArray(parent, { filter(node) {
+    return node._localName === localName && node._namespaceURI === namespace && node !== parent;
+  } });
+};
+
+exports.childrenByLocalNames = (parent, localNamesSet, namespace = HTML_NS) => {
+  return domSymbolTree.childrenToArray(parent, { filter(node) {
+    return localNamesSet.has(node._localName) && node._namespaceURI === namespace;
+  } });
+};
+
+exports.descendantsByLocalNames = (parent, localNamesSet, namespace = HTML_NS) => {
+  return domSymbolTree.treeToArray(parent, { filter(node) {
+    return localNamesSet.has(node._localName) &&
+           node._namespaceURI === namespace &&
+           node !== parent;
+  } });
+};
+
+exports.firstChildWithLocalName = (parent, localName, namespace = HTML_NS) => {
+  const iterator = domSymbolTree.childrenIterator(parent);
+  for (const child of iterator) {
+    if (child._localName === localName && child._namespaceURI === namespace) {
+      return child;
+    }
+  }
+  return null;
+};
+
+exports.firstChildWithLocalNames = (parent, localNamesSet, namespace = HTML_NS) => {
+  const iterator = domSymbolTree.childrenIterator(parent);
+  for (const child of iterator) {
+    if (localNamesSet.has(child._localName) && child._namespaceURI === namespace) {
+      return child;
+    }
+  }
+  return null;
+};
+
+exports.firstDescendantWithLocalName = (parent, localName, namespace = HTML_NS) => {
+  const iterator = domSymbolTree.treeIterator(parent);
+  for (const descendant of iterator) {
+    if (descendant._localName === localName && descendant._namespaceURI === namespace) {
+      return descendant;
+    }
+  }
+  return null;
+};
diff --git a/lib/jsdom/living/helpers/validate-names.js b/lib/jsdom/living/helpers/validate-names.js
new file mode 100644
index 0000000..99b03af
--- /dev/null
+++ b/lib/jsdom/living/helpers/validate-names.js
@@ -0,0 +1,75 @@
+"use strict";
+const xnv = require("xml-name-validator");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { XML_NS, XMLNS_NS } = require("./namespaces");
+
+// https://dom.spec.whatwg.org/#validate
+
+exports.name = function (globalObject, name) {
+  const result = xnv.name(name);
+  if (!result.success) {
+    throw DOMException.create(globalObject, [
+      "\"" + name + "\" did not match the Name production: " + result.error,
+      "InvalidCharacterError"
+    ]);
+  }
+};
+
+exports.qname = function (globalObject, qname) {
+  exports.name(globalObject, qname);
+
+  const result = xnv.qname(qname);
+  if (!result.success) {
+    throw DOMException.create(globalObject, [
+      "\"" + qname + "\" did not match the QName production: " + result.error,
+      "InvalidCharacterError"
+    ]);
+  }
+};
+
+exports.validateAndExtract = function (globalObject, namespace, qualifiedName) {
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  exports.qname(globalObject, qualifiedName);
+
+  let prefix = null;
+  let localName = qualifiedName;
+
+  const colonIndex = qualifiedName.indexOf(":");
+  if (colonIndex !== -1) {
+    prefix = qualifiedName.substring(0, colonIndex);
+    localName = qualifiedName.substring(colonIndex + 1);
+  }
+
+  if (prefix !== null && namespace === null) {
+    throw DOMException.create(globalObject, [
+      "A namespace was given but a prefix was also extracted from the qualifiedName",
+      "NamespaceError"
+    ]);
+  }
+
+  if (prefix === "xml" && namespace !== XML_NS) {
+    throw DOMException.create(globalObject, [
+      "A prefix of \"xml\" was given but the namespace was not the XML namespace",
+      "NamespaceError"
+    ]);
+  }
+
+  if ((qualifiedName === "xmlns" || prefix === "xmlns") && namespace !== XMLNS_NS) {
+    throw DOMException.create(globalObject, [
+      "A prefix or qualifiedName of \"xmlns\" was given but the namespace was not the XMLNS namespace",
+      "NamespaceError"
+    ]);
+  }
+
+  if (namespace === XMLNS_NS && qualifiedName !== "xmlns" && prefix !== "xmlns") {
+    throw DOMException.create(globalObject, [
+      "The XMLNS namespace was given but neither the prefix nor qualifiedName was \"xmlns\"",
+      "NamespaceError"
+    ]);
+  }
+
+  return { namespace, prefix, localName };
+};
diff --git a/lib/jsdom/living/helpers/wrap-cookie-jar-for-request.js b/lib/jsdom/living/helpers/wrap-cookie-jar-for-request.js
new file mode 100644
index 0000000..09ef872
--- /dev/null
+++ b/lib/jsdom/living/helpers/wrap-cookie-jar-for-request.js
@@ -0,0 +1,8 @@
+"use strict";
+const request = require("request");
+
+module.exports = cookieJar => {
+  const jarWrapper = request.jar();
+  jarWrapper._jar = cookieJar;
+  return jarWrapper;
+};
diff --git a/lib/jsdom/living/hr-time/Performance-impl.js b/lib/jsdom/living/hr-time/Performance-impl.js
new file mode 100644
index 0000000..564ea6d
--- /dev/null
+++ b/lib/jsdom/living/hr-time/Performance-impl.js
@@ -0,0 +1,25 @@
+"use strict";
+
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+
+class PerformanceImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._rawPerformance = privateData.rawPerformance;
+  }
+
+  now() {
+    return this._rawPerformance.now();
+  }
+
+  get timeOrigin() {
+    return this._rawPerformance.timeOrigin;
+  }
+
+  toJSON() {
+    return this._rawPerformance.toJSON();
+  }
+}
+
+exports.implementation = PerformanceImpl;
diff --git a/lib/jsdom/living/interfaces.js b/lib/jsdom/living/interfaces.js
new file mode 100644
index 0000000..2c06e6a
--- /dev/null
+++ b/lib/jsdom/living/interfaces.js
@@ -0,0 +1,219 @@
+/* eslint-disable global-require */
+"use strict";
+
+
+const style = require("../level2/style");
+const xpath = require("../level3/xpath");
+const nodeFilter = require("./node-filter");
+
+// This object defines the mapping between the interface name and the generated interface wrapper code.
+// Note: The mapping needs to stay as-is in order due to interface evaluation.
+// We cannot "refactor" this to something less duplicative because that would break bundlers which depend on static
+// analysis of require()s.
+const generatedInterfaces = {
+  DOMException: require("domexception/webidl2js-wrapper"),
+
+  URL: require("whatwg-url/webidl2js-wrapper").URL,
+  URLSearchParams: require("whatwg-url/webidl2js-wrapper").URLSearchParams,
+
+  EventTarget: require("./generated/EventTarget"),
+
+  NamedNodeMap: require("./generated/NamedNodeMap"),
+  Node: require("./generated/Node"),
+  Attr: require("./generated/Attr"),
+  Element: require("./generated/Element"),
+  DocumentFragment: require("./generated/DocumentFragment"),
+  Document: require("./generated/Document"),
+  XMLDocument: require("./generated/XMLDocument"),
+  CharacterData: require("./generated/CharacterData"),
+  Text: require("./generated/Text"),
+  CDATASection: require("./generated/CDATASection"),
+  ProcessingInstruction: require("./generated/ProcessingInstruction"),
+  Comment: require("./generated/Comment"),
+  DocumentType: require("./generated/DocumentType"),
+  DOMImplementation: require("./generated/DOMImplementation"),
+  NodeList: require("./generated/NodeList"),
+  HTMLCollection: require("./generated/HTMLCollection"),
+  HTMLOptionsCollection: require("./generated/HTMLOptionsCollection"),
+  DOMStringMap: require("./generated/DOMStringMap"),
+  DOMTokenList: require("./generated/DOMTokenList"),
+
+  HTMLElement: require("./generated/HTMLElement.js"),
+  HTMLHeadElement: require("./generated/HTMLHeadElement.js"),
+  HTMLTitleElement: require("./generated/HTMLTitleElement.js"),
+  HTMLBaseElement: require("./generated/HTMLBaseElement.js"),
+  HTMLLinkElement: require("./generated/HTMLLinkElement.js"),
+  HTMLMetaElement: require("./generated/HTMLMetaElement.js"),
+  HTMLStyleElement: require("./generated/HTMLStyleElement.js"),
+  HTMLBodyElement: require("./generated/HTMLBodyElement.js"),
+  HTMLHeadingElement: require("./generated/HTMLHeadingElement.js"),
+  HTMLParagraphElement: require("./generated/HTMLParagraphElement.js"),
+  HTMLHRElement: require("./generated/HTMLHRElement.js"),
+  HTMLPreElement: require("./generated/HTMLPreElement.js"),
+  HTMLUListElement: require("./generated/HTMLUListElement.js"),
+  HTMLOListElement: require("./generated/HTMLOListElement.js"),
+  HTMLLIElement: require("./generated/HTMLLIElement.js"),
+  HTMLMenuElement: require("./generated/HTMLMenuElement.js"),
+  HTMLDListElement: require("./generated/HTMLDListElement.js"),
+  HTMLDivElement: require("./generated/HTMLDivElement.js"),
+  HTMLAnchorElement: require("./generated/HTMLAnchorElement.js"),
+  HTMLAreaElement: require("./generated/HTMLAreaElement.js"),
+  HTMLBRElement: require("./generated/HTMLBRElement.js"),
+  HTMLButtonElement: require("./generated/HTMLButtonElement.js"),
+  HTMLCanvasElement: require("./generated/HTMLCanvasElement.js"),
+  HTMLDataElement: require("./generated/HTMLDataElement.js"),
+  HTMLDataListElement: require("./generated/HTMLDataListElement.js"),
+  HTMLDetailsElement: require("./generated/HTMLDetailsElement.js"),
+  HTMLDialogElement: require("./generated/HTMLDialogElement.js"),
+  HTMLDirectoryElement: require("./generated/HTMLDirectoryElement.js"),
+  HTMLFieldSetElement: require("./generated/HTMLFieldSetElement.js"),
+  HTMLFontElement: require("./generated/HTMLFontElement.js"),
+  HTMLFormElement: require("./generated/HTMLFormElement.js"),
+  HTMLHtmlElement: require("./generated/HTMLHtmlElement.js"),
+  HTMLImageElement: require("./generated/HTMLImageElement.js"),
+  HTMLInputElement: require("./generated/HTMLInputElement.js"),
+  HTMLLabelElement: require("./generated/HTMLLabelElement.js"),
+  HTMLLegendElement: require("./generated/HTMLLegendElement.js"),
+  HTMLMapElement: require("./generated/HTMLMapElement.js"),
+  HTMLMarqueeElement: require("./generated/HTMLMarqueeElement.js"),
+  HTMLMediaElement: require("./generated/HTMLMediaElement.js"),
+  HTMLMeterElement: require("./generated/HTMLMeterElement.js"),
+  HTMLModElement: require("./generated/HTMLModElement.js"),
+  HTMLOptGroupElement: require("./generated/HTMLOptGroupElement.js"),
+  HTMLOptionElement: require("./generated/HTMLOptionElement.js"),
+  HTMLOutputElement: require("./generated/HTMLOutputElement.js"),
+  HTMLPictureElement: require("./generated/HTMLPictureElement.js"),
+  HTMLProgressElement: require("./generated/HTMLProgressElement.js"),
+  HTMLQuoteElement: require("./generated/HTMLQuoteElement.js"),
+  HTMLScriptElement: require("./generated/HTMLScriptElement.js"),
+  HTMLSelectElement: require("./generated/HTMLSelectElement.js"),
+  HTMLSlotElement: require("./generated/HTMLSlotElement.js"),
+  HTMLSourceElement: require("./generated/HTMLSourceElement.js"),
+  HTMLSpanElement: require("./generated/HTMLSpanElement.js"),
+  HTMLTableCaptionElement: require("./generated/HTMLTableCaptionElement.js"),
+  HTMLTableCellElement: require("./generated/HTMLTableCellElement.js"),
+  HTMLTableColElement: require("./generated/HTMLTableColElement.js"),
+  HTMLTableElement: require("./generated/HTMLTableElement.js"),
+  HTMLTimeElement: require("./generated/HTMLTimeElement.js"),
+  HTMLTableRowElement: require("./generated/HTMLTableRowElement.js"),
+  HTMLTableSectionElement: require("./generated/HTMLTableSectionElement.js"),
+  HTMLTemplateElement: require("./generated/HTMLTemplateElement.js"),
+  HTMLTextAreaElement: require("./generated/HTMLTextAreaElement.js"),
+  HTMLUnknownElement: require("./generated/HTMLUnknownElement.js"),
+  HTMLFrameElement: require("./generated/HTMLFrameElement.js"),
+  HTMLFrameSetElement: require("./generated/HTMLFrameSetElement.js"),
+  HTMLIFrameElement: require("./generated/HTMLIFrameElement.js"),
+  HTMLEmbedElement: require("./generated/HTMLEmbedElement.js"),
+  HTMLObjectElement: require("./generated/HTMLObjectElement.js"),
+  HTMLParamElement: require("./generated/HTMLParamElement.js"),
+  HTMLVideoElement: require("./generated/HTMLVideoElement.js"),
+  HTMLAudioElement: require("./generated/HTMLAudioElement.js"),
+  HTMLTrackElement: require("./generated/HTMLTrackElement.js"),
+
+  SVGElement: require("./generated/SVGElement.js"),
+  SVGGraphicsElement: require("./generated/SVGGraphicsElement.js"),
+  SVGSVGElement: require("./generated/SVGSVGElement.js"),
+  SVGTitleElement: require("./generated/SVGTitleElement.js"),
+  SVGAnimatedString: require("./generated/SVGAnimatedString"),
+  SVGNumber: require("./generated/SVGNumber"),
+  SVGStringList: require("./generated/SVGStringList"),
+
+  Event: require("./generated/Event"),
+  CloseEvent: require("./generated/CloseEvent"),
+  CustomEvent: require("./generated/CustomEvent"),
+  MessageEvent: require("./generated/MessageEvent"),
+  ErrorEvent: require("./generated/ErrorEvent"),
+  HashChangeEvent: require("./generated/HashChangeEvent"),
+  PopStateEvent: require("./generated/PopStateEvent"),
+  StorageEvent: require("./generated/StorageEvent"),
+  ProgressEvent: require("./generated/ProgressEvent"),
+  PageTransitionEvent: require("./generated/PageTransitionEvent"),
+
+  UIEvent: require("./generated/UIEvent"),
+  FocusEvent: require("./generated/FocusEvent"),
+  InputEvent: require("./generated/InputEvent"),
+  MouseEvent: require("./generated/MouseEvent"),
+  KeyboardEvent: require("./generated/KeyboardEvent"),
+  TouchEvent: require("./generated/TouchEvent"),
+  CompositionEvent: require("./generated/CompositionEvent"),
+  WheelEvent: require("./generated/WheelEvent"),
+
+  BarProp: require("./generated/BarProp"),
+  External: require("./generated/External"),
+  Location: require("./generated/Location"),
+  History: require("./generated/History"),
+  Screen: require("./generated/Screen"),
+  Performance: require("./generated/Performance"),
+  Navigator: require("./generated/Navigator"),
+
+  PluginArray: require("./generated/PluginArray"),
+  MimeTypeArray: require("./generated/MimeTypeArray"),
+  Plugin: require("./generated/Plugin"),
+  MimeType: require("./generated/MimeType"),
+
+  FileReader: require("./generated/FileReader"),
+  Blob: require("./generated/Blob"),
+  File: require("./generated/File"),
+  FileList: require("./generated/FileList"),
+  ValidityState: require("./generated/ValidityState"),
+
+  DOMParser: require("./generated/DOMParser"),
+  XMLSerializer: require("./generated/XMLSerializer"),
+
+  FormData: require("./generated/FormData"),
+  XMLHttpRequestEventTarget: require("./generated/XMLHttpRequestEventTarget"),
+  XMLHttpRequestUpload: require("./generated/XMLHttpRequestUpload"),
+  XMLHttpRequest: require("./generated/XMLHttpRequest"),
+  WebSocket: require("./generated/WebSocket"),
+
+  NodeIterator: require("./generated/NodeIterator"),
+  TreeWalker: require("./generated/TreeWalker"),
+
+  AbstractRange: require("./generated/AbstractRange"),
+  Range: require("./generated/Range"),
+  StaticRange: require("./generated/StaticRange"),
+  Selection: require("./generated/Selection"),
+
+  Storage: require("./generated/Storage"),
+
+  CustomElementRegistry: require("./generated/CustomElementRegistry"),
+  ShadowRoot: require("./generated/ShadowRoot"),
+
+  MutationObserver: require("./generated/MutationObserver"),
+  MutationRecord: require("./generated/MutationRecord"),
+
+  Headers: require("./generated/Headers"),
+  AbortController: require("./generated/AbortController"),
+  AbortSignal: require("./generated/AbortSignal")
+};
+
+function install(window, name, interfaceConstructor) {
+  Object.defineProperty(window, name, {
+    configurable: true,
+    writable: true,
+    value: interfaceConstructor
+  });
+}
+
+exports.installInterfaces = window => {
+  // Install generated interface.
+  for (const generatedInterface of Object.values(generatedInterfaces)) {
+    generatedInterface.install(window);
+  }
+
+  // Install legacy HTMLDocument interface
+  // https://html.spec.whatwg.org/#htmldocument
+  install(window, "HTMLDocument", window.Document);
+
+  // These need to be cleaned up...
+  style.addToCore(window);
+  xpath(window);
+
+  // This one is OK but needs migration to webidl2js eventually.
+  nodeFilter(window);
+};
+
+// Returns an interface webidl2js wrapper given its an interface name.
+exports.getInterfaceWrapper = name => {
+  return generatedInterfaces[name];
+};
diff --git a/lib/jsdom/living/mutation-observer/MutationObserver-impl.js b/lib/jsdom/living/mutation-observer/MutationObserver-impl.js
new file mode 100644
index 0000000..3057da8
--- /dev/null
+++ b/lib/jsdom/living/mutation-observer/MutationObserver-impl.js
@@ -0,0 +1,95 @@
+"use strict";
+
+const { wrapperForImpl } = require("../generated/utils");
+
+// If we were to implement the MutationObserver by spec, the MutationObservers will not be collected by the GC because
+// all the MO are kept in a mutation observer list (https://github.com/jsdom/jsdom/pull/2398/files#r238123889). The
+// mutation observer list is primarily used to invoke the mutation observer callback in the same order than the
+// mutation observer creation.
+// In order to get around this issue, we will assign an increasing id for each mutation observer, this way we would be
+// able to invoke the callback in the creation order without having to keep a list of all the mutation observers.
+let mutationObserverId = 0;
+
+// https://dom.spec.whatwg.org/#mutationobserver
+class MutationObserverImpl {
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-mutationobserver
+  constructor(globalObject, args) {
+    const [callback] = args;
+
+    this._callback = callback;
+    this._nodeList = [];
+    this._recordQueue = [];
+
+    this._id = ++mutationObserverId;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-observe
+  observe(target, options) {
+    if (("attributeOldValue" in options || "attributeFilter" in options) && !("attributes" in options)) {
+      options.attributes = true;
+    }
+
+    if ("characterDataOldValue" in options & !("characterData" in options)) {
+      options.characterData = true;
+    }
+
+    if (!options.childList && !options.attributes && !options.characterData) {
+      throw new TypeError("The options object must set at least one of 'attributes', 'characterData', or 'childList' " +
+        "to true.");
+    } else if (options.attributeOldValue && !options.attributes) {
+      throw new TypeError("The options object may only set 'attributeOldValue' to true when 'attributes' is true or " +
+        "not present.");
+    } else if (("attributeFilter" in options) && !options.attributes) {
+      throw new TypeError("The options object may only set 'attributeFilter' when 'attributes' is true or not " +
+        "present.");
+    } else if (options.characterDataOldValue && !options.characterData) {
+      throw new TypeError("The options object may only set 'characterDataOldValue' to true when 'characterData' is " +
+        "true or not present.");
+    }
+
+    const existingRegisteredObserver = target._registeredObserverList.find(registeredObserver => {
+      return registeredObserver.observer === this;
+    });
+
+    if (existingRegisteredObserver) {
+      for (const node of this._nodeList) {
+        node._registeredObserverList = node._registeredObserverList.filter(registeredObserver => {
+          return registeredObserver.source !== existingRegisteredObserver;
+        });
+      }
+
+      existingRegisteredObserver.options = options;
+    } else {
+      target._registeredObserverList.push({
+        observer: this,
+        options
+      });
+
+      this._nodeList.push(target);
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-disconnect
+  disconnect() {
+    for (const node of this._nodeList) {
+      node._registeredObserverList = node._registeredObserverList.filter(registeredObserver => {
+        return registeredObserver.observer !== this;
+      });
+    }
+
+    this._recordQueue = [];
+  }
+
+  // https://dom.spec.whatwg.org/#dom-mutationobserver-takerecords
+  takeRecords() {
+    // TODO: revisit if https://github.com/jsdom/webidl2js/pull/108 gets fixed.
+    const records = this._recordQueue.map(wrapperForImpl);
+    this._recordQueue = [];
+
+    return records;
+  }
+}
+
+module.exports = {
+  implementation: MutationObserverImpl
+};
diff --git a/lib/jsdom/living/mutation-observer/MutationRecord-impl.js b/lib/jsdom/living/mutation-observer/MutationRecord-impl.js
new file mode 100644
index 0000000..fc16f3b
--- /dev/null
+++ b/lib/jsdom/living/mutation-observer/MutationRecord-impl.js
@@ -0,0 +1,37 @@
+"use strict";
+
+const NodeList = require("../generated/NodeList");
+
+// https://dom.spec.whatwg.org/#mutationrecord
+class MutationRecordImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+
+    this.type = privateData.type;
+    this.target = privateData.target;
+    this.previousSibling = privateData.previousSibling;
+    this.nextSibling = privateData.nextSibling;
+    this.attributeName = privateData.attributeName;
+    this.attributeNamespace = privateData.attributeNamespace;
+    this.oldValue = privateData.oldValue;
+
+    this._addedNodes = privateData.addedNodes;
+    this._removedNodes = privateData.removedNodes;
+  }
+
+  get addedNodes() {
+    return NodeList.createImpl(this._globalObject, [], {
+      nodes: this._addedNodes
+    });
+  }
+
+  get removedNodes() {
+    return NodeList.createImpl(this._globalObject, [], {
+      nodes: this._removedNodes
+    });
+  }
+}
+
+module.exports = {
+  implementation: MutationRecordImpl
+};
diff --git a/lib/jsdom/living/named-properties-window.js b/lib/jsdom/living/named-properties-window.js
new file mode 100644
index 0000000..a820951
--- /dev/null
+++ b/lib/jsdom/living/named-properties-window.js
@@ -0,0 +1,141 @@
+"use strict";
+const hasOwnProp = Object.prototype.hasOwnProperty;
+const namedPropertiesTracker = require("../named-properties-tracker");
+const NODE_TYPE = require("./node-type");
+const HTMLCollection = require("./generated/HTMLCollection");
+const { treeOrderSorter } = require("../utils");
+const idlUtils = require("./generated/utils");
+
+function isNamedPropertyElement(element) {
+  // (for the name attribute)
+
+  // use hasOwnProperty to make sure contentWindow comes from the prototype,
+  // and is not set directly on the node by a script.
+  if ("contentWindow" in element && !hasOwnProp.call(element, "contentWindow")) {
+    return true;
+  }
+
+  switch (element.nodeName) {
+    case "A":
+    case "AREA":
+    case "EMBED":
+    case "FORM":
+    case "FRAMESET":
+    case "IMG":
+    case "OBJECT":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function namedPropertyResolver(window, name, values) {
+  function getResult() {
+    const results = [];
+
+    for (const node of values().keys()) {
+      if (node.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+        continue;
+      }
+
+      if (node.getAttributeNS(null, "id") === name) {
+        results.push(node);
+      } else if (node.getAttributeNS(null, "name") === name && isNamedPropertyElement(node)) {
+        results.push(node);
+      }
+    }
+
+    results.sort(treeOrderSorter);
+
+    return results;
+  }
+
+  const document = window._document;
+  const objects = HTMLCollection.create(window, [], {
+    element: idlUtils.implForWrapper(document.documentElement),
+    query: getResult
+  });
+
+  const { length } = objects;
+  for (let i = 0; i < length; ++i) {
+    const node = objects[i];
+
+    if ("contentWindow" in node && !hasOwnProp.call(node, "contentWindow") &&
+       node.getAttributeNS(null, "name") === name) {
+      return node.contentWindow;
+    }
+  }
+
+  if (length === 0) {
+    return undefined;
+  }
+
+  if (length === 1) {
+    return objects[0];
+  }
+
+  return objects;
+}
+
+exports.initializeWindow = function (window, windowProxy) {
+  namedPropertiesTracker.create(window, windowProxy, namedPropertyResolver.bind(null));
+};
+
+exports.elementAttributeModified = function (element, name, value, oldValue) {
+  if (!element._attached) {
+    return;
+  }
+
+  const useName = isNamedPropertyElement(element);
+
+  if (name === "id" || (name === "name" && useName)) {
+    const tracker = namedPropertiesTracker.get(element._ownerDocument._global);
+
+    // (tracker will be null if the document has no Window)
+    if (tracker) {
+      if (name === "id" && (!useName || element.getAttributeNS(null, "name") !== oldValue)) {
+        tracker.untrack(oldValue, element);
+      }
+
+      if (name === "name" && element.getAttributeNS(null, "id") !== oldValue) {
+        tracker.untrack(oldValue, element);
+      }
+
+      tracker.track(value, element);
+    }
+  }
+};
+
+exports.nodeAttachedToDocument = function (node) {
+  if (node.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+    return;
+  }
+
+  const tracker = namedPropertiesTracker.get(node._ownerDocument._global);
+  if (!tracker) {
+    return;
+  }
+
+  tracker.track(node.getAttributeNS(null, "id"), node);
+
+  if (isNamedPropertyElement(node)) {
+    tracker.track(node.getAttributeNS(null, "name"), node);
+  }
+};
+
+exports.nodeDetachedFromDocument = function (node) {
+  if (node.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+    return;
+  }
+
+  const tracker = namedPropertiesTracker.get(node._ownerDocument._global);
+  if (!tracker) {
+    return;
+  }
+
+  tracker.untrack(node.getAttributeNS(null, "id"), node);
+
+  if (isNamedPropertyElement(node)) {
+    tracker.untrack(node.getAttributeNS(null, "name"), node);
+  }
+};
diff --git a/lib/jsdom/living/navigator/MimeType-impl.js b/lib/jsdom/living/navigator/MimeType-impl.js
new file mode 100644
index 0000000..e251c2a
--- /dev/null
+++ b/lib/jsdom/living/navigator/MimeType-impl.js
@@ -0,0 +1,3 @@
+"use strict";
+
+exports.implementation = class MimeType {};
diff --git a/lib/jsdom/living/navigator/MimeTypeArray-impl.js b/lib/jsdom/living/navigator/MimeTypeArray-impl.js
new file mode 100644
index 0000000..c590838
--- /dev/null
+++ b/lib/jsdom/living/navigator/MimeTypeArray-impl.js
@@ -0,0 +1,25 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+
+exports.implementation = class MimeTypeArray {
+  get length() {
+    return 0;
+  }
+
+  item() {
+    return null;
+  }
+
+  namedItem() {
+    return null;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return [];
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    return [];
+  }
+};
diff --git a/lib/jsdom/living/navigator/Navigator-impl.js b/lib/jsdom/living/navigator/Navigator-impl.js
new file mode 100644
index 0000000..257d3fd
--- /dev/null
+++ b/lib/jsdom/living/navigator/Navigator-impl.js
@@ -0,0 +1,25 @@
+"use strict";
+const { mixin } = require("../../utils");
+const NavigatorIDImpl = require("./NavigatorID-impl").implementation;
+const NavigatorLanguageImpl = require("./NavigatorLanguage-impl").implementation;
+const NavigatorOnLineImpl = require("./NavigatorOnLine-impl").implementation;
+const NavigatorCookiesImpl = require("./NavigatorCookies-impl").implementation;
+const NavigatorPluginsImpl = require("./NavigatorPlugins-impl").implementation;
+const NavigatorConcurrentHardwareImpl = require("./NavigatorConcurrentHardware-impl").implementation;
+
+class NavigatorImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+    this.userAgent = privateData.userAgent;
+    this.languages = Object.freeze(["en-US", "en"]);
+  }
+}
+
+mixin(NavigatorImpl.prototype, NavigatorIDImpl.prototype);
+mixin(NavigatorImpl.prototype, NavigatorLanguageImpl.prototype);
+mixin(NavigatorImpl.prototype, NavigatorOnLineImpl.prototype);
+mixin(NavigatorImpl.prototype, NavigatorCookiesImpl.prototype);
+mixin(NavigatorImpl.prototype, NavigatorPluginsImpl.prototype);
+mixin(NavigatorImpl.prototype, NavigatorConcurrentHardwareImpl.prototype);
+
+exports.implementation = NavigatorImpl;
diff --git a/lib/jsdom/living/navigator/NavigatorConcurrentHardware-impl.js b/lib/jsdom/living/navigator/NavigatorConcurrentHardware-impl.js
new file mode 100644
index 0000000..4fd29ad
--- /dev/null
+++ b/lib/jsdom/living/navigator/NavigatorConcurrentHardware-impl.js
@@ -0,0 +1,8 @@
+"use strict";
+const os = require("os");
+
+exports.implementation = class NavigatorConcurrentHardwareImpl {
+  get hardwareConcurrency() {
+    return os.cpus().length;
+  }
+};
diff --git a/lib/jsdom/living/navigator/NavigatorCookies-impl.js b/lib/jsdom/living/navigator/NavigatorCookies-impl.js
new file mode 100644
index 0000000..a66f677
--- /dev/null
+++ b/lib/jsdom/living/navigator/NavigatorCookies-impl.js
@@ -0,0 +1,7 @@
+"use strict";
+
+exports.implementation = class NavigatorCookiesImpl {
+  get cookieEnabled() {
+    return true;
+  }
+};
diff --git a/lib/jsdom/living/navigator/NavigatorID-impl.js b/lib/jsdom/living/navigator/NavigatorID-impl.js
new file mode 100644
index 0000000..50aac66
--- /dev/null
+++ b/lib/jsdom/living/navigator/NavigatorID-impl.js
@@ -0,0 +1,37 @@
+"use strict";
+
+exports.implementation = class NavigatorIDImpl {
+  get appCodeName() {
+    return "Mozilla";
+  }
+
+  get appName() {
+    return "Netscape";
+  }
+
+  get appVersion() {
+    return "4.0";
+  }
+
+  get platform() {
+    return "";
+  }
+
+  get product() {
+    return "Gecko";
+  }
+
+  get productSub() {
+    return "20030107";
+  }
+
+  // see Navigator constructor for userAgent
+
+  get vendor() {
+    return "Apple Computer, Inc.";
+  }
+
+  get vendorSub() {
+    return "";
+  }
+};
diff --git a/lib/jsdom/living/navigator/NavigatorLanguage-impl.js b/lib/jsdom/living/navigator/NavigatorLanguage-impl.js
new file mode 100644
index 0000000..136a3fd
--- /dev/null
+++ b/lib/jsdom/living/navigator/NavigatorLanguage-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+exports.implementation = class NavigatorLanguageImpl {
+  get language() {
+    return "en-US";
+  }
+
+  // See Navigator constructor for languages
+};
diff --git a/lib/jsdom/living/navigator/NavigatorOnLine-impl.js b/lib/jsdom/living/navigator/NavigatorOnLine-impl.js
new file mode 100644
index 0000000..44a9779
--- /dev/null
+++ b/lib/jsdom/living/navigator/NavigatorOnLine-impl.js
@@ -0,0 +1,7 @@
+"use strict";
+
+exports.implementation = class NavigatorOnLineImpl {
+  get onLine() {
+    return true;
+  }
+};
diff --git a/lib/jsdom/living/navigator/NavigatorPlugins-impl.js b/lib/jsdom/living/navigator/NavigatorPlugins-impl.js
new file mode 100644
index 0000000..620626a
--- /dev/null
+++ b/lib/jsdom/living/navigator/NavigatorPlugins-impl.js
@@ -0,0 +1,18 @@
+"use strict";
+
+const PluginArray = require("../generated/PluginArray");
+const MimeTypeArray = require("../generated/MimeTypeArray");
+
+exports.implementation = class NavigatorPluginsImpl {
+  get plugins() {
+    return PluginArray.create(this._globalObject);
+  }
+
+  get mimeTypes() {
+    return MimeTypeArray.create(this._globalObject);
+  }
+
+  javaEnabled() {
+    return false;
+  }
+};
diff --git a/lib/jsdom/living/navigator/Plugin-impl.js b/lib/jsdom/living/navigator/Plugin-impl.js
new file mode 100644
index 0000000..eff02fe
--- /dev/null
+++ b/lib/jsdom/living/navigator/Plugin-impl.js
@@ -0,0 +1,3 @@
+"use strict";
+
+exports.implementation = class Plugin {};
diff --git a/lib/jsdom/living/navigator/PluginArray-impl.js b/lib/jsdom/living/navigator/PluginArray-impl.js
new file mode 100644
index 0000000..dab5687
--- /dev/null
+++ b/lib/jsdom/living/navigator/PluginArray-impl.js
@@ -0,0 +1,27 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+
+exports.implementation = class PluginArray {
+  refresh() {}
+
+  get length() {
+    return 0;
+  }
+
+  item() {
+    return null;
+  }
+
+  namedItem() {
+    return null;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return [];
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    return [];
+  }
+};
diff --git a/lib/jsdom/living/node-document-position.js b/lib/jsdom/living/node-document-position.js
new file mode 100644
index 0000000..06485c0
--- /dev/null
+++ b/lib/jsdom/living/node-document-position.js
@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = Object.freeze({
+  DOCUMENT_POSITION_DISCONNECTED: 1,
+  DOCUMENT_POSITION_PRECEDING: 2,
+  DOCUMENT_POSITION_FOLLOWING: 4,
+  DOCUMENT_POSITION_CONTAINS: 8,
+  DOCUMENT_POSITION_CONTAINED_BY: 16,
+  DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32
+});
diff --git a/lib/jsdom/living/node-filter.js b/lib/jsdom/living/node-filter.js
new file mode 100644
index 0000000..1522850
--- /dev/null
+++ b/lib/jsdom/living/node-filter.js
@@ -0,0 +1,47 @@
+"use strict";
+const { addConstants } = require("../utils");
+
+module.exports = function (core) {
+  // https://dom.spec.whatwg.org/#interface-nodefilter
+  core.NodeFilter = function () {
+    throw new TypeError("Illegal constructor");
+  };
+
+  /**
+   * Returns an unsigned short that will be used to tell if a given Node must
+   * be accepted or not by the NodeIterator or TreeWalker iteration
+   * algorithm. This method is expected to be written by the user of a
+   * NodeFilter.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/NodeFilter
+   * @interface
+   *
+   * @param  {Node} node DOM Node
+   * @return {FILTER_ACCEPT|FILTER_REJECT|FILTER_SKIP}
+   */
+  core.NodeFilter.acceptNode = function (/* node */) {
+    throw new Error("This method is expected to be written by the user of a NodeFilter.");
+  };
+
+  addConstants(core.NodeFilter, {
+    // Constants for whatToShow
+    SHOW_ALL: 0xFFFFFFFF,
+    SHOW_ELEMENT: 0x00000001,
+    SHOW_ATTRIBUTE: 0x00000002,
+    SHOW_TEXT: 0x00000004,
+    SHOW_CDATA_SECTION: 0x00000008,
+    SHOW_ENTITY_REFERENCE: 0x00000010,
+    SHOW_ENTITY: 0x00000020,
+    SHOW_PROCESSING_INSTRUCTION: 0x00000040,
+    SHOW_COMMENT: 0x00000080,
+    SHOW_DOCUMENT: 0x00000100,
+    SHOW_DOCUMENT_TYPE: 0x00000200,
+    SHOW_DOCUMENT_FRAGMENT: 0x00000400,
+    SHOW_NOTATION: 0x00000800,
+
+    // Constants returned by acceptNode
+    FILTER_ACCEPT: 1,
+    FILTER_REJECT: 2,
+    FILTER_SKIP: 3
+  });
+};
diff --git a/lib/jsdom/living/node-type.js b/lib/jsdom/living/node-type.js
new file mode 100644
index 0000000..96f3405
--- /dev/null
+++ b/lib/jsdom/living/node-type.js
@@ -0,0 +1,16 @@
+"use strict";
+
+module.exports = Object.freeze({
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  TEXT_NODE: 3,
+  CDATA_SECTION_NODE: 4, // historical
+  ENTITY_REFERENCE_NODE: 5, // historical
+  ENTITY_NODE: 6, // historical
+  PROCESSING_INSTRUCTION_NODE: 7,
+  COMMENT_NODE: 8,
+  DOCUMENT_NODE: 9,
+  DOCUMENT_TYPE_NODE: 10,
+  DOCUMENT_FRAGMENT_NODE: 11,
+  NOTATION_NODE: 12 // historical
+});
diff --git a/lib/jsdom/living/node.js b/lib/jsdom/living/node.js
new file mode 100644
index 0000000..2aa208d
--- /dev/null
+++ b/lib/jsdom/living/node.js
@@ -0,0 +1,336 @@
+"use strict";
+const { appendAttribute } = require("./attributes");
+const NODE_TYPE = require("./node-type");
+
+const orderedSetParse = require("./helpers/ordered-set").parse;
+const { createElement } = require("./helpers/create-element");
+const { HTML_NS, XMLNS_NS } = require("./helpers/namespaces");
+const { cloningSteps, domSymbolTree } = require("./helpers/internal-constants");
+const { asciiCaseInsensitiveMatch, asciiLowercase } = require("./helpers/strings");
+
+const HTMLCollection = require("./generated/HTMLCollection");
+
+exports.clone = (node, document, cloneChildren) => {
+  if (document === undefined) {
+    document = node._ownerDocument;
+  }
+
+  let copy;
+  switch (node.nodeType) {
+    case NODE_TYPE.DOCUMENT_NODE:
+      // Can't use a simple Document.createImpl because of circular dependency issues :-/
+      copy = document.implementation.createDocument(null, "", null);
+      copy._encoding = node._encoding;
+      copy.contentType = node.contentType;
+      copy._URL = node._URL;
+      copy._origin = node._origin;
+      copy._parsingMode = node._parsingMode;
+      break;
+
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+      copy = document.implementation.createDocumentType(node.name, node.publicId, node.systemId);
+      break;
+
+    case NODE_TYPE.ELEMENT_NODE:
+      copy = createElement(
+        document,
+        node._localName,
+        node._namespaceURI,
+        node._prefix,
+        node._isValue,
+        false
+      );
+
+      for (const attribute of node._attributeList) {
+        appendAttribute(copy, exports.clone(attribute, document));
+      }
+      break;
+
+    case NODE_TYPE.ATTRIBUTE_NODE:
+      copy = document._createAttribute({
+        namespace: node._namespace,
+        namespacePrefix: node._namespacePrefix,
+        localName: node._localName,
+        value: node._value
+      });
+      break;
+
+    case NODE_TYPE.TEXT_NODE:
+      copy = document.createTextNode(node._data);
+      break;
+
+    case NODE_TYPE.CDATA_SECTION_NODE:
+      copy = document.createCDATASection(node._data);
+      break;
+
+    case NODE_TYPE.COMMENT_NODE:
+      copy = document.createComment(node._data);
+      break;
+
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      copy = document.createProcessingInstruction(node.target, node._data);
+      break;
+
+    case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+      copy = document.createDocumentFragment();
+      break;
+  }
+
+  if (node[cloningSteps]) {
+    node[cloningSteps](copy, node, document, cloneChildren);
+  }
+
+  if (cloneChildren) {
+    for (const child of domSymbolTree.childrenIterator(node)) {
+      const childCopy = exports.clone(child, document, true);
+      copy._append(childCopy);
+    }
+  }
+
+  return copy;
+};
+
+// For the following, memoization is not applied here since the memoized results are stored on `this`.
+
+exports.listOfElementsWithClassNames = (classNames, root) => {
+  // https://dom.spec.whatwg.org/#concept-getElementsByClassName
+
+  const classes = orderedSetParse(classNames);
+
+  if (classes.size === 0) {
+    return HTMLCollection.createImpl(root._globalObject, [], { element: root, query: () => [] });
+  }
+
+  return HTMLCollection.createImpl(root._globalObject, [], {
+    element: root,
+    query: () => {
+      const isQuirksMode = root._ownerDocument.compatMode === "BackCompat";
+
+      return domSymbolTree.treeToArray(root, { filter(node) {
+        if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+          return false;
+        }
+
+        const { classList } = node;
+        if (isQuirksMode) {
+          for (const className of classes) {
+            if (!classList.tokenSet.some(cur => asciiCaseInsensitiveMatch(cur, className))) {
+              return false;
+            }
+          }
+        } else {
+          for (const className of classes) {
+            if (!classList.tokenSet.contains(className)) {
+              return false;
+            }
+          }
+        }
+
+        return true;
+      } });
+    }
+  });
+};
+
+exports.listOfElementsWithQualifiedName = (qualifiedName, root) => {
+  // https://dom.spec.whatwg.org/#concept-getelementsbytagname
+
+  if (qualifiedName === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE && node !== root
+      })
+    });
+  }
+
+  if (root._ownerDocument._parsingMode === "html") {
+    const lowerQualifiedName = asciiLowercase(qualifiedName);
+
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter(node) {
+          if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+            return false;
+          }
+
+          if (node._namespaceURI === HTML_NS) {
+            return node._qualifiedName === lowerQualifiedName;
+          }
+
+          return node._qualifiedName === qualifiedName;
+        }
+      })
+    });
+  }
+
+  return HTMLCollection.createImpl(root._globalObject, [], {
+    element: root,
+    query: () => domSymbolTree.treeToArray(root, {
+      filter(node) {
+        if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+          return false;
+        }
+
+        return node._qualifiedName === qualifiedName;
+      }
+    })
+  });
+};
+
+exports.listOfElementsWithNamespaceAndLocalName = (namespace, localName, root) => {
+  // https://dom.spec.whatwg.org/#concept-getelementsbytagnamens
+
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  if (namespace === "*" && localName === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE && node !== root
+      })
+    });
+  }
+
+  if (namespace === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter(node) {
+          if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+            return false;
+          }
+
+          return node._localName === localName;
+        }
+      })
+    });
+  }
+
+  if (localName === "*") {
+    return HTMLCollection.createImpl(root._globalObject, [], {
+      element: root,
+      query: () => domSymbolTree.treeToArray(root, {
+        filter(node) {
+          if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+            return false;
+          }
+
+          return node._namespaceURI === namespace;
+        }
+      })
+    });
+  }
+
+  return HTMLCollection.createImpl(root._globalObject, [], {
+    element: root,
+    query: () => domSymbolTree.treeToArray(root, {
+      filter(node) {
+        if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+          return false;
+        }
+
+        return node._localName === localName && node._namespaceURI === namespace;
+      }
+    })
+  });
+};
+
+// https://dom.spec.whatwg.org/#converting-nodes-into-a-node
+// create a fragment (or just return a node for one item)
+exports.convertNodesIntoNode = (document, nodes) => {
+  if (nodes.length === 1) { // note: I'd prefer to check instanceof Node rather than string
+    return typeof nodes[0] === "string" ? document.createTextNode(nodes[0]) : nodes[0];
+  }
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < nodes.length; i++) {
+    fragment._append(typeof nodes[i] === "string" ? document.createTextNode(nodes[i]) : nodes[i]);
+  }
+  return fragment;
+};
+
+// https://dom.spec.whatwg.org/#locate-a-namespace-prefix
+exports.locateNamespacePrefix = (element, namespace) => {
+  if (element._namespaceURI === namespace && element._prefix !== null) {
+    return element._prefix;
+  }
+
+  for (const attribute of element._attributeList) {
+    if (attribute._namespacePrefix === "xmlns" && attribute._value === namespace) {
+      return attribute._localName;
+    }
+  }
+
+  if (element.parentElement !== null) {
+    return exports.locateNamespacePrefix(element.parentElement, namespace);
+  }
+
+  return null;
+};
+
+// https://dom.spec.whatwg.org/#locate-a-namespace
+exports.locateNamespace = (node, prefix) => {
+  switch (node.nodeType) {
+    case NODE_TYPE.ELEMENT_NODE: {
+      if (node._namespaceURI !== null && node._prefix === prefix) {
+        return node._namespaceURI;
+      }
+
+      if (prefix === null) {
+        for (const attribute of node._attributeList) {
+          if (attribute._namespace === XMLNS_NS &&
+              attribute._namespacePrefix === null &&
+              attribute._localName === "xmlns") {
+            return attribute._value !== "" ? attribute._value : null;
+          }
+        }
+      } else {
+        for (const attribute of node._attributeList) {
+          if (attribute._namespace === XMLNS_NS &&
+              attribute._namespacePrefix === "xmlns" &&
+              attribute._localName === prefix) {
+            return attribute._value !== "" ? attribute._value : null;
+          }
+        }
+      }
+
+      if (node.parentElement === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node.parentElement, prefix);
+    }
+
+    case NODE_TYPE.DOCUMENT_NODE: {
+      if (node.documentElement === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node.documentElement, prefix);
+    }
+
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+    case NODE_TYPE.DOCUMENT_FRAGMENT_NODE: {
+      return null;
+    }
+
+    case NODE_TYPE.ATTRIBUTE_NODE: {
+      if (node._element === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node._element, prefix);
+    }
+
+    default: {
+      if (node.parentElement === null) {
+        return null;
+      }
+
+      return exports.locateNamespace(node.parentElement, prefix);
+    }
+  }
+};
diff --git a/lib/jsdom/living/nodes/CDATASection-impl.js b/lib/jsdom/living/nodes/CDATASection-impl.js
new file mode 100644
index 0000000..d9e6248
--- /dev/null
+++ b/lib/jsdom/living/nodes/CDATASection-impl.js
@@ -0,0 +1,16 @@
+"use strict";
+
+const TextImpl = require("./Text-impl").implementation;
+const NODE_TYPE = require("../node-type");
+
+class CDATASectionImpl extends TextImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.nodeType = NODE_TYPE.CDATA_SECTION_NODE;
+  }
+}
+
+module.exports = {
+  implementation: CDATASectionImpl
+};
diff --git a/lib/jsdom/living/nodes/CharacterData-impl.js b/lib/jsdom/living/nodes/CharacterData-impl.js
new file mode 100644
index 0000000..4c051d8
--- /dev/null
+++ b/lib/jsdom/living/nodes/CharacterData-impl.js
@@ -0,0 +1,118 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const { mixin } = require("../../utils");
+const NodeImpl = require("./Node-impl").implementation;
+const ChildNodeImpl = require("./ChildNode-impl").implementation;
+const NonDocumentTypeChildNodeImpl = require("./NonDocumentTypeChildNode-impl").implementation;
+
+const { TEXT_NODE } = require("../node-type");
+const { MUTATION_TYPE, queueMutationRecord } = require("../helpers/mutation-observers");
+
+// https://dom.spec.whatwg.org/#characterdata
+class CharacterDataImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._data = privateData.data;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-data
+  get data() {
+    return this._data;
+  }
+  set data(data) {
+    this.replaceData(0, this.length, data);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-length
+  get length() {
+    return this._data.length;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-substringdata
+  // https://dom.spec.whatwg.org/#concept-cd-substring
+  substringData(offset, count) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    if (offset + count > length) {
+      return this._data.slice(offset);
+    }
+
+    return this._data.slice(offset, offset + count);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-appenddata
+  appendData(data) {
+    this.replaceData(this.length, 0, data);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-insertdata
+  insertData(offset, data) {
+    this.replaceData(offset, 0, data);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-deletedata
+  deleteData(offset, count) {
+    this.replaceData(offset, count, "");
+  }
+
+  // https://dom.spec.whatwg.org/#dom-characterdata-replacedata
+  // https://dom.spec.whatwg.org/#concept-cd-replace
+  replaceData(offset, count, data) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, [
+        "The index is not in the allowed range.",
+        "IndexSizeError"
+      ]);
+    }
+
+    if (offset + count > length) {
+      count = length - offset;
+    }
+
+    queueMutationRecord(MUTATION_TYPE.CHARACTER_DATA, this, null, null, this._data, [], [], null, null);
+
+    const start = this._data.slice(0, offset);
+    const end = this._data.slice(offset + count);
+    this._data = start + data + end;
+
+    for (const range of this._referencedRanges) {
+      const { _start, _end } = range;
+
+      if (_start.offset > offset && _start.offset <= offset + count) {
+        range._setLiveRangeStart(this, offset);
+      }
+
+      if (_end.offset > offset && _end.offset <= offset + count) {
+        range._setLiveRangeEnd(this, offset);
+      }
+
+      if (_start.offset > offset + count) {
+        range._setLiveRangeStart(this, _start.offset + data.length - count);
+      }
+
+      if (_end.offset > offset + count) {
+        range._setLiveRangeEnd(this, _end.offset + data.length - count);
+      }
+    }
+
+    if (this.nodeType === TEXT_NODE && this.parentNode) {
+      this.parentNode._childTextContentChangeSteps();
+    }
+  }
+}
+
+mixin(CharacterDataImpl.prototype, NonDocumentTypeChildNodeImpl.prototype);
+mixin(CharacterDataImpl.prototype, ChildNodeImpl.prototype);
+
+module.exports = {
+  implementation: CharacterDataImpl
+};
diff --git a/lib/jsdom/living/nodes/ChildNode-impl.js b/lib/jsdom/living/nodes/ChildNode-impl.js
new file mode 100644
index 0000000..799e44f
--- /dev/null
+++ b/lib/jsdom/living/nodes/ChildNode-impl.js
@@ -0,0 +1,80 @@
+"use strict";
+
+const { convertNodesIntoNode } = require("../node");
+
+class ChildNodeImpl {
+  remove() {
+    if (!this.parentNode) {
+      return;
+    }
+
+    this.parentNode._remove(this);
+  }
+
+  after(...nodes) {
+    const parent = this.parentNode;
+    if (parent) {
+      let viableNextSibling = this.nextSibling;
+      let idx = viableNextSibling ? nodes.indexOf(viableNextSibling) : -1;
+
+      while (idx !== -1) {
+        viableNextSibling = viableNextSibling.nextSibling;
+        if (!viableNextSibling) {
+          break;
+        }
+        idx = nodes.indexOf(viableNextSibling);
+      }
+
+      parent._preInsert(convertNodesIntoNode(this._ownerDocument, nodes), viableNextSibling);
+    }
+  }
+
+  before(...nodes) {
+    const parent = this.parentNode;
+    if (parent) {
+      let viablePreviousSibling = this.previousSibling;
+      let idx = viablePreviousSibling ? nodes.indexOf(viablePreviousSibling) : -1;
+
+      while (idx !== -1) {
+        viablePreviousSibling = viablePreviousSibling.previousSibling;
+        if (!viablePreviousSibling) {
+          break;
+        }
+        idx = nodes.indexOf(viablePreviousSibling);
+      }
+
+      parent._preInsert(
+        convertNodesIntoNode(this._ownerDocument, nodes),
+        viablePreviousSibling ? viablePreviousSibling.nextSibling : parent.firstChild
+      );
+    }
+  }
+
+  replaceWith(...nodes) {
+    const parent = this.parentNode;
+    if (parent) {
+      let viableNextSibling = this.nextSibling;
+      let idx = viableNextSibling ? nodes.indexOf(viableNextSibling) : -1;
+
+      while (idx !== -1) {
+        viableNextSibling = viableNextSibling.nextSibling;
+        if (!viableNextSibling) {
+          break;
+        }
+        idx = nodes.indexOf(viableNextSibling);
+      }
+
+      const node = convertNodesIntoNode(this._ownerDocument, nodes);
+
+      if (this.parentNode === parent) {
+        parent._replace(node, this);
+      } else {
+        parent._preInsert(node, viableNextSibling);
+      }
+    }
+  }
+}
+
+module.exports = {
+  implementation: ChildNodeImpl
+};
diff --git a/lib/jsdom/living/nodes/Comment-impl.js b/lib/jsdom/living/nodes/Comment-impl.js
new file mode 100644
index 0000000..a02c988
--- /dev/null
+++ b/lib/jsdom/living/nodes/Comment-impl.js
@@ -0,0 +1,20 @@
+"use strict";
+
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const NODE_TYPE = require("../node-type");
+
+class CommentImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, {
+      data: args[0],
+      ...privateData
+    });
+
+    this.nodeType = NODE_TYPE.COMMENT_NODE;
+  }
+}
+
+module.exports = {
+  implementation: CommentImpl
+};
diff --git a/lib/jsdom/living/nodes/DOMImplementation-impl.js b/lib/jsdom/living/nodes/DOMImplementation-impl.js
new file mode 100644
index 0000000..288ee97
--- /dev/null
+++ b/lib/jsdom/living/nodes/DOMImplementation-impl.js
@@ -0,0 +1,118 @@
+"use strict";
+
+const validateNames = require("../helpers/validate-names");
+const { HTML_NS, SVG_NS } = require("../helpers/namespaces");
+const { createElement, internalCreateElementNSSteps } = require("../helpers/create-element");
+
+const DocumentType = require("../generated/DocumentType");
+const Document = require("../generated/Document");
+
+class DOMImplementationImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+    this._ownerDocument = privateData.ownerDocument;
+  }
+
+  hasFeature() {
+    return true;
+  }
+
+  createDocumentType(qualifiedName, publicId, systemId) {
+    validateNames.qname(this._globalObject, qualifiedName);
+
+    return DocumentType.createImpl(this._globalObject, [], {
+      ownerDocument: this._ownerDocument,
+      name: qualifiedName,
+      publicId,
+      systemId
+    });
+  }
+
+  // https://dom.spec.whatwg.org/#dom-domimplementation-createdocument
+  createDocument(namespace, qualifiedName, doctype) {
+    let contentType = "application/xml";
+
+    if (namespace === HTML_NS) {
+      contentType = "application/xhtml+xml";
+    } else if (namespace === SVG_NS) {
+      contentType = "image/svg+xml";
+    }
+
+    const document = Document.createImpl(this._globalObject, [], {
+      options: { contentType, parsingMode: "xml", encoding: "UTF-8" }
+    });
+
+    let element = null;
+    if (qualifiedName !== "") {
+      element = internalCreateElementNSSteps(document, namespace, qualifiedName, {});
+    }
+
+    if (doctype !== null) {
+      document.appendChild(doctype);
+    }
+
+    if (element !== null) {
+      document.appendChild(element);
+    }
+
+    document._origin = this._ownerDocument._origin;
+
+    return document;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
+  createHTMLDocument(title) {
+    // Let doc be a new document that is an HTML document.
+    // Set doc's content type to "text/html".
+    const document = Document.createImpl(this._globalObject, [], {
+      options: { parsingMode: "html", encoding: "UTF-8" }
+    });
+
+    // Create a doctype, with "html" as its name and with its node document set
+    // to doc. Append the newly created node to doc.
+    const doctype = DocumentType.createImpl(this._globalObject, [], {
+      ownerDocument: this,
+      name: "html",
+      publicId: "",
+      systemId: ""
+    });
+
+    document.appendChild(doctype);
+
+    // Create an html element in the HTML namespace, and append it to doc.
+    const htmlElement = createElement(document, "html", HTML_NS);
+    document.appendChild(htmlElement);
+
+    // Create a head element in the HTML namespace, and append it to the html
+    // element created in the previous step.
+    const headElement = createElement(document, "head", HTML_NS);
+    htmlElement.appendChild(headElement);
+
+    // If the title argument is not omitted:
+    if (title !== undefined) {
+      // Create a title element in the HTML namespace, and append it to the head
+      // element created in the previous step.
+      const titleElement = createElement(document, "title", HTML_NS);
+      headElement.appendChild(titleElement);
+
+      // Create a Text node, set its data to title (which could be the empty
+      // string), and append it to the title element created in the previous step.
+      titleElement.appendChild(document.createTextNode(title));
+    }
+
+    // Create a body element in the HTML namespace, and append it to the html
+    // element created in the earlier step.
+    const bodyElement = createElement(document, "body", HTML_NS);
+    htmlElement.appendChild(bodyElement);
+
+    // doc's origin is an alias to the origin of the context object's associated
+    // document, and doc's effective script origin is an alias to the effective
+    // script origin of the context object's associated document.
+
+    return document;
+  }
+}
+
+module.exports = {
+  implementation: DOMImplementationImpl
+};
diff --git a/lib/jsdom/living/nodes/DOMStringMap-impl.js b/lib/jsdom/living/nodes/DOMStringMap-impl.js
new file mode 100644
index 0000000..b8861aa
--- /dev/null
+++ b/lib/jsdom/living/nodes/DOMStringMap-impl.js
@@ -0,0 +1,64 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+const { setAttributeValue, removeAttributeByName } = require("../attributes");
+const validateName = require("../helpers/validate-names").name;
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const dataAttrRe = /^data-([^A-Z]*)$/;
+
+function attrCamelCase(name) {
+  return name.replace(/-([a-z])/g, (match, alpha) => alpha.toUpperCase());
+}
+
+function attrSnakeCase(name) {
+  return name.replace(/[A-Z]/g, match => `-${match.toLowerCase()}`);
+}
+
+exports.implementation = class DOMStringMapImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+    this._element = privateData.element;
+  }
+  get [idlUtils.supportedPropertyNames]() {
+    const result = new Set();
+    const { attributes } = this._element;
+    for (let i = 0; i < attributes.length; i++) {
+      const attr = attributes.item(i);
+      const matches = dataAttrRe.exec(attr.localName);
+      if (matches) {
+        result.add(attrCamelCase(matches[1]));
+      }
+    }
+    return result;
+  }
+  [idlUtils.namedGet](name) {
+    const { attributes } = this._element;
+    for (let i = 0; i < attributes.length; i++) {
+      const attr = attributes.item(i);
+      const matches = dataAttrRe.exec(attr.localName);
+      if (matches && attrCamelCase(matches[1]) === name) {
+        return attr.value;
+      }
+    }
+    return undefined;
+  }
+  [idlUtils.namedSetNew](name, value) {
+    if (/-[a-z]/.test(name)) {
+      throw DOMException.create(this._globalObject, [
+        `'${name}' is not a valid property name`,
+        "SyntaxError"
+      ]);
+    }
+    name = `data-${attrSnakeCase(name)}`;
+    validateName(this._globalObject, name);
+    setAttributeValue(this._element, name, value);
+  }
+  [idlUtils.namedSetExisting](name, value) {
+    this[idlUtils.namedSetNew](name, value);
+  }
+  [idlUtils.namedDelete](name) {
+    name = `data-${attrSnakeCase(name)}`;
+    removeAttributeByName(this._element, name);
+  }
+};
diff --git a/lib/jsdom/living/nodes/DOMTokenList-impl.js b/lib/jsdom/living/nodes/DOMTokenList-impl.js
new file mode 100644
index 0000000..96dbd44
--- /dev/null
+++ b/lib/jsdom/living/nodes/DOMTokenList-impl.js
@@ -0,0 +1,171 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const OrderedSet = require("../helpers/ordered-set.js");
+const { asciiLowercase } = require("../helpers/strings.js");
+const idlUtils = require("../generated/utils.js");
+
+const { getAttributeValue, setAttributeValue, hasAttributeByName } = require("../attributes.js");
+
+function validateTokens(globalObject, ...tokens) {
+  for (const token of tokens) {
+    if (token === "") {
+      throw DOMException.create(globalObject, ["The token provided must not be empty.", "SyntaxError"]);
+    }
+  }
+  for (const token of tokens) {
+    if (/[\t\n\f\r ]/.test(token)) {
+      throw DOMException.create(globalObject, [
+        "The token provided contains HTML space characters, which are not valid in tokens.",
+        "InvalidCharacterError"
+      ]);
+    }
+  }
+}
+
+// https://dom.spec.whatwg.org/#domtokenlist
+class DOMTokenListImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+
+    // _syncWithElement() must always be called before any _tokenSet access.
+    this._tokenSet = new OrderedSet();
+    this._element = privateData.element;
+    this._attributeLocalName = privateData.attributeLocalName;
+    this._supportedTokens = privateData.supportedTokens;
+
+    // Needs synchronization with element if token set is to be accessed.
+    this._dirty = true;
+  }
+
+  attrModified() {
+    this._dirty = true;
+  }
+
+  _syncWithElement() {
+    if (!this._dirty) {
+      return;
+    }
+
+    const val = getAttributeValue(this._element, this._attributeLocalName);
+    if (val === null) {
+      this._tokenSet.empty();
+    } else {
+      this._tokenSet = OrderedSet.parse(val);
+    }
+
+    this._dirty = false;
+  }
+
+  _validationSteps(token) {
+    if (!this._supportedTokens) {
+      throw new TypeError(`${this._attributeLocalName} attribute has no supported tokens`);
+    }
+    const lowerToken = asciiLowercase(token);
+    return this._supportedTokens.has(lowerToken);
+  }
+
+  _updateSteps() {
+    if (!hasAttributeByName(this._element, this._attributeLocalName) && this._tokenSet.isEmpty()) {
+      return;
+    }
+    setAttributeValue(this._element, this._attributeLocalName, this._tokenSet.serialize());
+  }
+
+  _serializeSteps() {
+    return getAttributeValue(this._element, this._attributeLocalName);
+  }
+
+  // Used by other parts of jsdom
+  get tokenSet() {
+    this._syncWithElement();
+    return this._tokenSet;
+  }
+
+  get length() {
+    this._syncWithElement();
+    return this._tokenSet.size;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    this._syncWithElement();
+    return this._tokenSet.keys();
+  }
+
+  item(index) {
+    this._syncWithElement();
+    if (index >= this._tokenSet.size) {
+      return null;
+    }
+    return this._tokenSet.get(index);
+  }
+
+  contains(token) {
+    this._syncWithElement();
+    return this._tokenSet.contains(token);
+  }
+
+  add(...tokens) {
+    for (const token of tokens) {
+      validateTokens(this._globalObject, token);
+    }
+    this._syncWithElement();
+    for (const token of tokens) {
+      this._tokenSet.append(token);
+    }
+    this._updateSteps();
+  }
+
+  remove(...tokens) {
+    for (const token of tokens) {
+      validateTokens(this._globalObject, token);
+    }
+    this._syncWithElement();
+    this._tokenSet.remove(...tokens);
+    this._updateSteps();
+  }
+
+  toggle(token, force = undefined) {
+    validateTokens(this._globalObject, token);
+    this._syncWithElement();
+    if (this._tokenSet.contains(token)) {
+      if (force === undefined || force === false) {
+        this._tokenSet.remove(token);
+        this._updateSteps();
+        return false;
+      }
+      return true;
+    }
+    if (force === undefined || force === true) {
+      this._tokenSet.append(token);
+      this._updateSteps();
+      return true;
+    }
+    return false;
+  }
+
+  replace(token, newToken) {
+    validateTokens(this._globalObject, token, newToken);
+    this._syncWithElement();
+    if (!this._tokenSet.contains(token)) {
+      return false;
+    }
+    this._tokenSet.replace(token, newToken);
+    this._updateSteps();
+    return true;
+  }
+
+  supports(token) {
+    return this._validationSteps(token);
+  }
+
+  get value() {
+    return this._serializeSteps();
+  }
+
+  set value(V) {
+    setAttributeValue(this._element, this._attributeLocalName, V);
+  }
+}
+
+exports.implementation = DOMTokenListImpl;
diff --git a/lib/jsdom/living/nodes/Document-impl.js b/lib/jsdom/living/nodes/Document-impl.js
new file mode 100644
index 0000000..799c892
--- /dev/null
+++ b/lib/jsdom/living/nodes/Document-impl.js
@@ -0,0 +1,922 @@
+"use strict";
+
+const { CookieJar } = require("tough-cookie");
+
+const NodeImpl = require("./Node-impl").implementation;
+const idlUtils = require("../generated/utils");
+const NODE_TYPE = require("../node-type");
+const { mixin, memoizeQuery } = require("../../utils");
+const { firstChildWithLocalName, firstChildWithLocalNames, firstDescendantWithLocalName } =
+  require("../helpers/traversal");
+const whatwgURL = require("whatwg-url");
+const { StyleSheetList } = require("../../level2/style");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const eventAccessors = require("../helpers/create-event-accessor");
+const { asciiLowercase, stripAndCollapseASCIIWhitespace } = require("../helpers/strings");
+const { childTextContent } = require("../helpers/text");
+const { HTML_NS, SVG_NS } = require("../helpers/namespaces");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { parseIntoDocument } = require("../../browser/parser");
+const History = require("../generated/History");
+const Location = require("../generated/Location");
+const HTMLCollection = require("../generated/HTMLCollection");
+const NodeList = require("../generated/NodeList");
+const validateName = require("../helpers/validate-names").name;
+const { validateAndExtract } = require("../helpers/validate-names");
+const { fireAnEvent } = require("../helpers/events");
+const { shadowIncludingInclusiveDescendantsIterator } = require("../helpers/shadow-dom");
+const { enqueueCECallbackReaction } = require("../helpers/custom-elements");
+const { createElement, internalCreateElementNSSteps } = require("../helpers/create-element");
+
+const DocumentOrShadowRootImpl = require("./DocumentOrShadowRoot-impl").implementation;
+const GlobalEventHandlersImpl = require("./GlobalEventHandlers-impl").implementation;
+const NonElementParentNodeImpl = require("./NonElementParentNode-impl").implementation;
+const ParentNodeImpl = require("./ParentNode-impl").implementation;
+
+const { clone, listOfElementsWithQualifiedName, listOfElementsWithNamespaceAndLocalName,
+  listOfElementsWithClassNames } = require("../node");
+const generatedAttr = require("../generated/Attr");
+const Comment = require("../generated/Comment");
+const ProcessingInstruction = require("../generated/ProcessingInstruction");
+const CDATASection = require("../generated/CDATASection");
+const Text = require("../generated/Text");
+const DocumentFragment = require("../generated/DocumentFragment");
+const DOMImplementation = require("../generated/DOMImplementation");
+const TreeWalker = require("../generated/TreeWalker");
+const NodeIterator = require("../generated/NodeIterator");
+const ShadowRoot = require("../generated/ShadowRoot");
+const Range = require("../generated/Range");
+
+const CustomEvent = require("../generated/CustomEvent");
+const ErrorEvent = require("../generated/ErrorEvent");
+const Event = require("../generated/Event");
+const FocusEvent = require("../generated/FocusEvent");
+const HashChangeEvent = require("../generated/HashChangeEvent");
+const KeyboardEvent = require("../generated/KeyboardEvent");
+const MessageEvent = require("../generated/MessageEvent");
+const MouseEvent = require("../generated/MouseEvent");
+const PopStateEvent = require("../generated/PopStateEvent");
+const ProgressEvent = require("../generated/ProgressEvent");
+const TouchEvent = require("../generated/TouchEvent");
+const UIEvent = require("../generated/UIEvent");
+
+const RequestManager = require("../../browser/resources/request-manager");
+const AsyncResourceQueue = require("../../browser/resources/async-resource-queue");
+const ResourceQueue = require("../../browser/resources/resource-queue");
+const PerDocumentResourceLoader = require("../../browser/resources/per-document-resource-loader");
+
+function clearChildNodes(node) {
+  for (let child = domSymbolTree.firstChild(node); child; child = domSymbolTree.firstChild(node)) {
+    node.removeChild(child);
+  }
+}
+
+function pad(number) {
+  if (number < 10) {
+    return "0" + number;
+  }
+  return number;
+}
+
+function toLastModifiedString(date) {
+  return pad(date.getMonth() + 1) +
+    "/" + pad(date.getDate()) +
+    "/" + date.getFullYear() +
+    " " + pad(date.getHours()) +
+    ":" + pad(date.getMinutes()) +
+    ":" + pad(date.getSeconds());
+}
+
+const eventInterfaceTable = {
+  customevent: CustomEvent,
+  errorevent: ErrorEvent,
+  event: Event,
+  events: Event,
+  focusevent: FocusEvent,
+  hashchangeevent: HashChangeEvent,
+  htmlevents: Event,
+  keyboardevent: KeyboardEvent,
+  messageevent: MessageEvent,
+  mouseevent: MouseEvent,
+  mouseevents: MouseEvent,
+  popstateevent: PopStateEvent,
+  progressevent: ProgressEvent,
+  svgevents: Event,
+  touchevent: TouchEvent,
+  uievent: UIEvent,
+  uievents: UIEvent
+};
+
+class DocumentImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._initGlobalEvents();
+
+    this._ownerDocument = this;
+    this.nodeType = NODE_TYPE.DOCUMENT_NODE;
+    if (!privateData.options) {
+      privateData.options = {};
+    }
+    if (!privateData.options.parsingMode) {
+      privateData.options.parsingMode = "xml";
+    }
+    if (!privateData.options.encoding) {
+      privateData.options.encoding = "UTF-8";
+    }
+    if (!privateData.options.contentType) {
+      privateData.options.contentType = privateData.options.parsingMode === "xml" ? "application/xml" : "text/html";
+    }
+
+    this._parsingMode = privateData.options.parsingMode;
+
+    this._implementation = DOMImplementation.createImpl(this._globalObject, [], {
+      ownerDocument: this
+    });
+
+    this._defaultView = privateData.options.defaultView || null;
+    this._global = privateData.options.global;
+    this._ids = Object.create(null);
+    this._attached = true;
+    this._currentScript = null;
+    this._pageShowingFlag = false;
+    this._cookieJar = privateData.options.cookieJar;
+    this._parseOptions = privateData.options.parseOptions;
+    this._scriptingDisabled = privateData.options.scriptingDisabled;
+    if (this._cookieJar === undefined) {
+      this._cookieJar = new CookieJar(null, { looseMode: true });
+    }
+
+    this.contentType = privateData.options.contentType;
+    this._encoding = privateData.options.encoding;
+
+    const urlOption = privateData.options.url === undefined ? "about:blank" : privateData.options.url;
+    const parsed = whatwgURL.parseURL(urlOption);
+    if (parsed === null) {
+      throw new TypeError(`Could not parse "${urlOption}" as a URL`);
+    }
+
+    this._URL = parsed;
+    this._origin = whatwgURL.serializeURLOrigin(parsed);
+
+    this._location = Location.createImpl(this._globalObject, [], { relevantDocument: this });
+    this._history = History.createImpl(this._globalObject, [], {
+      window: this._defaultView,
+      document: this,
+      actAsIfLocationReloadCalled: () => this._location.reload()
+    });
+
+    this._workingNodeIterators = [];
+    this._workingNodeIteratorsMax = privateData.options.concurrentNodeIterators === undefined ?
+                                    10 :
+                                    Number(privateData.options.concurrentNodeIterators);
+
+    if (isNaN(this._workingNodeIteratorsMax)) {
+      throw new TypeError("The 'concurrentNodeIterators' option must be a Number");
+    }
+
+    if (this._workingNodeIteratorsMax < 0) {
+      throw new RangeError("The 'concurrentNodeIterators' option must be a non negative Number");
+    }
+
+    this._referrer = privateData.options.referrer || "";
+    this._lastModified = toLastModifiedString(privateData.options.lastModified || new Date());
+    this._asyncQueue = new AsyncResourceQueue();
+    this._queue = new ResourceQueue({ asyncQueue: this._asyncQueue, paused: false });
+    this._deferQueue = new ResourceQueue({ paused: true });
+    this._requestManager = new RequestManager();
+    this._currentDocumentReadiness = privateData.options.readyState || "loading";
+
+    this._lastFocusedElement = null;
+
+    this._resourceLoader = new PerDocumentResourceLoader(this);
+
+    // Each Document in a browsing context can also have a latest entry. This is the entry for that Document
+    // to which the browsing context's session history was most recently traversed. When a Document is created,
+    // it initially has no latest entry.
+    this._latestEntry = null;
+
+    // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#throw-on-dynamic-markup-insertion-counter
+    this._throwOnDynamicMarkupInsertionCounter = 0;
+  }
+
+  _getTheParent(event) {
+    if (event.type === "load" || !this._defaultView) {
+      return null;
+    }
+
+    return idlUtils.implForWrapper(this._defaultView);
+  }
+
+  get compatMode() {
+    return this._parsingMode === "xml" || this.doctype ? "CSS1Compat" : "BackCompat";
+  }
+  get charset() {
+    return this._encoding;
+  }
+  get characterSet() {
+    return this._encoding;
+  }
+  get inputEncoding() {
+    return this._encoding;
+  }
+  get doctype() {
+    for (const childNode of domSymbolTree.childrenIterator(this)) {
+      if (childNode.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) {
+        return childNode;
+      }
+    }
+    return null;
+  }
+  get URL() {
+    return whatwgURL.serializeURL(this._URL);
+  }
+  get documentURI() {
+    return whatwgURL.serializeURL(this._URL);
+  }
+  get location() {
+    return this._defaultView ? this._location : null;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-document-documentelement
+  get documentElement() {
+    for (const childNode of domSymbolTree.childrenIterator(this)) {
+      if (childNode.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return childNode;
+      }
+    }
+
+    return null;
+  }
+
+  get implementation() {
+    return this._implementation;
+  }
+  set implementation(implementation) {
+    this._implementation = implementation;
+  }
+
+  get defaultView() {
+    return this._defaultView;
+  }
+
+  get currentScript() {
+    return this._currentScript;
+  }
+
+  get readyState() {
+    return this._currentDocumentReadiness;
+  }
+
+  set readyState(state) {
+    this._currentDocumentReadiness = state;
+    fireAnEvent("readystatechange", this);
+  }
+
+  hasFocus() {
+    return Boolean(this._lastFocusedElement);
+  }
+
+  _descendantRemoved(parent, child) {
+    if (child.tagName === "STYLE") {
+      const index = this.styleSheets.indexOf(child.sheet);
+      if (index > -1) {
+        this.styleSheets.splice(index, 1);
+      }
+    }
+
+    super._descendantRemoved.apply(this, arguments);
+  }
+
+  write() {
+    let text = "";
+    for (let i = 0; i < arguments.length; ++i) {
+      text += String(arguments[i]);
+    }
+
+    if (this._parsingMode === "xml") {
+      throw DOMException.create(this._globalObject, [
+        "Cannot use document.write on XML documents",
+        "InvalidStateError"
+      ]);
+    }
+
+    if (this._throwOnDynamicMarkupInsertionCounter > 0) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot use document.write while a custom element upgrades",
+        "InvalidStateError"
+      ]);
+    }
+
+    if (this._writeAfterElement) {
+      // If called from an script element directly (during the first tick),
+      // the new elements are inserted right after that element.
+      const tempDiv = this.createElement("div");
+      tempDiv.innerHTML = text;
+
+      let child = tempDiv.firstChild;
+      let previous = this._writeAfterElement;
+      const parent = this._writeAfterElement.parentNode;
+
+      while (child) {
+        const node = child;
+        child = child.nextSibling;
+
+        node._isMovingDueToDocumentWrite = true; // hack for script execution
+        parent.insertBefore(node, previous.nextSibling);
+        node._isMovingDueToDocumentWrite = false;
+
+        previous = node;
+      }
+    } else if (this.readyState === "loading") {
+      // During page loading, document.write appends to the current element
+      // Find the last child that has been added to the document.
+      if (this.lastChild) {
+        let node = this;
+        while (node.lastChild && node.lastChild.nodeType === NODE_TYPE.ELEMENT_NODE) {
+          node = node.lastChild;
+        }
+        node.innerHTML = text;
+      } else {
+        clearChildNodes(this);
+        parseIntoDocument(text, this);
+      }
+    } else if (text) {
+      clearChildNodes(this);
+      parseIntoDocument(text, this);
+    }
+  }
+
+  writeln() {
+    this.write(...arguments, "\n");
+  }
+
+  // This is implemented separately for Document (which has a _ids cache) and DocumentFragment (which does not).
+  getElementById(id) {
+    if (!this._ids[id]) {
+      return null;
+    }
+
+    // Let's find the first element with where it's root is the document.
+    const matchElement = this._ids[id].find(candidate => {
+      let root = candidate;
+      while (domSymbolTree.parent(root)) {
+        root = domSymbolTree.parent(root);
+      }
+
+      return root === this;
+    });
+
+    return matchElement || null;
+  }
+
+  get referrer() {
+    return this._referrer || "";
+  }
+  get lastModified() {
+    return this._lastModified;
+  }
+  get images() {
+    return this.getElementsByTagName("IMG");
+  }
+  get embeds() {
+    return this.getElementsByTagName("EMBED");
+  }
+  get plugins() {
+    return this.embeds;
+  }
+  get links() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => domSymbolTree.treeToArray(this, {
+        filter: node => (node._localName === "a" || node._localName === "area") &&
+                        node.hasAttributeNS(null, "href") &&
+                        node._namespaceURI === HTML_NS
+      })
+    });
+  }
+  get forms() {
+    return this.getElementsByTagName("FORM");
+  }
+  get scripts() {
+    return this.getElementsByTagName("SCRIPT");
+  }
+  get anchors() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => domSymbolTree.treeToArray(this, {
+        filter: node => node._localName === "a" &&
+                        node.hasAttributeNS(null, "name") &&
+                        node._namespaceURI === HTML_NS
+      })
+    });
+  }
+
+  // The applets attribute must return an
+  // HTMLCollection rooted at the Document node,
+  // whose filter matches nothing.
+  // (It exists for historical reasons.)
+  get applets() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => []
+    });
+  }
+
+  open() {
+    let child = domSymbolTree.firstChild(this);
+    while (child) {
+      this.removeChild(child);
+      child = domSymbolTree.firstChild(this);
+    }
+    this._modified();
+    return this;
+  }
+  close(noQueue) {
+    // In some cases like when creating an empty iframe, I want to emit the
+    // events right away to avoid problems if later I asign the property src.
+    if (noQueue) {
+      this.readyState = "complete";
+
+      fireAnEvent("DOMContentLoaded", this, undefined, { bubbles: true });
+      fireAnEvent("load", this);
+
+      return;
+    }
+    this._queue.resume();
+
+    const dummyPromise = Promise.resolve();
+
+    const onDOMContentLoad = () => {
+      const doc = this;
+      function dispatchEvent() {
+        // https://html.spec.whatwg.org/#the-end
+        doc.readyState = "interactive";
+        fireAnEvent("DOMContentLoaded", doc, undefined, { bubbles: true });
+      }
+
+      return new Promise(resolve => {
+        if (!this._deferQueue.tail) {
+          dispatchEvent();
+          return resolve();
+        }
+
+        this._deferQueue.setListener(() => {
+          dispatchEvent();
+          resolve();
+        });
+
+        return this._deferQueue.resume();
+      });
+    };
+
+    const onLoad = () => {
+      const doc = this;
+      function dispatchEvent() {
+        doc.readyState = "complete";
+        fireAnEvent("load", doc);
+      }
+
+      return new Promise(resolve => {
+        if (this._asyncQueue.count() === 0) {
+          dispatchEvent();
+          return resolve();
+        }
+
+        return this._asyncQueue.setListener(() => {
+          dispatchEvent();
+          resolve();
+        });
+      });
+    };
+
+    this._queue.push(dummyPromise, onDOMContentLoad, null);
+    // Set the readyState to 'complete' once all resources are loaded.
+    // As a side-effect the document's load-event will be dispatched.
+    this._queue.push(dummyPromise, onLoad, null, true);
+  }
+
+  getElementsByName(elementName) {
+    return NodeList.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => domSymbolTree.treeToArray(this, {
+        filter: node => node.getAttributeNS && node.getAttributeNS(null, "name") === elementName
+      })
+    });
+  }
+
+  get title() {
+    const { documentElement } = this;
+    let value = "";
+
+    if (documentElement && documentElement._localName === "svg") {
+      const svgTitleElement = firstChildWithLocalName(documentElement, "title", SVG_NS);
+
+      if (svgTitleElement) {
+        value = childTextContent(svgTitleElement);
+      }
+    } else {
+      const titleElement = firstDescendantWithLocalName(this, "title");
+
+      if (titleElement) {
+        value = childTextContent(titleElement);
+      }
+    }
+
+    value = stripAndCollapseASCIIWhitespace(value);
+
+    return value;
+  }
+
+  set title(value) {
+    const { documentElement } = this;
+    let element;
+
+    if (documentElement && documentElement._localName === "svg") {
+      element = firstChildWithLocalName(documentElement, "title", SVG_NS);
+
+      if (!element) {
+        element = this.createElementNS(SVG_NS, "title");
+
+        this._insert(element, documentElement.firstChild);
+      }
+
+      element.textContent = value;
+    } else if (documentElement && documentElement._namespaceURI === HTML_NS) {
+      const titleElement = firstDescendantWithLocalName(this, "title");
+      const headElement = this.head;
+
+      if (titleElement === null && headElement === null) {
+        return;
+      }
+
+      if (titleElement !== null) {
+        element = titleElement;
+      } else {
+        element = this.createElement("title");
+        headElement._append(element);
+      }
+
+      element.textContent = value;
+    }
+  }
+
+  get dir() {
+    return this.documentElement ? this.documentElement.dir : "";
+  }
+  set dir(value) {
+    if (this.documentElement) {
+      this.documentElement.dir = value;
+    }
+  }
+
+  get head() {
+    return this.documentElement ? firstChildWithLocalName(this.documentElement, "head") : null;
+  }
+
+  get body() {
+    const { documentElement } = this;
+    if (!documentElement || documentElement._localName !== "html" ||
+        documentElement._namespaceURI !== HTML_NS) {
+      return null;
+    }
+
+    return firstChildWithLocalNames(this.documentElement, new Set(["body", "frameset"]));
+  }
+
+  set body(value) {
+    if (value === null ||
+        value._namespaceURI !== HTML_NS ||
+        (value._localName !== "body" && value._localName !== "frameset")) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot set the body to null or a non-body/frameset element",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    const bodyElement = this.body;
+    if (value === bodyElement) {
+      return;
+    }
+
+    if (bodyElement !== null) {
+      bodyElement.parentNode._replace(value, bodyElement);
+      return;
+    }
+
+    const { documentElement } = this;
+    if (documentElement === null) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot set the body when there is no document element",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    documentElement._append(value);
+  }
+
+  _runPreRemovingSteps(oldNode) {
+    for (const activeNodeIterator of this._workingNodeIterators) {
+      activeNodeIterator._preRemovingSteps(oldNode);
+    }
+  }
+
+  createEvent(type) {
+    const typeLower = type.toLowerCase();
+    const eventWrapper = eventInterfaceTable[typeLower] || null;
+
+    if (!eventWrapper) {
+      throw DOMException.create(this._globalObject, [
+        "The provided event type (\"" + type + "\") is invalid",
+        "NotSupportedError"
+      ]);
+    }
+
+    const impl = eventWrapper.createImpl(this._globalObject, [""]);
+    impl._initializedFlag = false;
+    return impl;
+  }
+
+  createRange() {
+    return Range.createImpl(this._globalObject, [], {
+      start: { node: this, offset: 0 },
+      end: { node: this, offset: 0 }
+    });
+  }
+
+  createProcessingInstruction(target, data) {
+    validateName(this._globalObject, target);
+
+    if (data.includes("?>")) {
+      throw DOMException.create(this._globalObject, [
+        "Processing instruction data cannot contain the string \"?>\"",
+        "InvalidCharacterError"
+      ]);
+    }
+
+    return ProcessingInstruction.createImpl(this._globalObject, [], {
+      ownerDocument: this,
+      target,
+      data
+    });
+  }
+
+  // https://dom.spec.whatwg.org/#dom-document-createcdatasection
+  createCDATASection(data) {
+    if (this._parsingMode === "html") {
+      throw DOMException.create(this._globalObject, [
+        "Cannot create CDATA sections in HTML documents",
+        "NotSupportedError"
+      ]);
+    }
+
+    if (data.includes("]]>")) {
+      throw DOMException.create(this._globalObject, [
+        "CDATA section data cannot contain the string \"]]>\"",
+        "InvalidCharacterError"
+      ]);
+    }
+
+    return CDATASection.createImpl(this._globalObject, [], {
+      ownerDocument: this,
+      data
+    });
+  }
+
+  createTextNode(data) {
+    return Text.createImpl(this._globalObject, [], {
+      ownerDocument: this,
+      data
+    });
+  }
+
+  createComment(data) {
+    return Comment.createImpl(this._globalObject, [], {
+      ownerDocument: this,
+      data
+    });
+  }
+
+  // https://dom.spec.whatwg.org/#dom-document-createelement
+  createElement(localName, options) {
+    validateName(this._globalObject, localName);
+
+    if (this._parsingMode === "html") {
+      localName = asciiLowercase(localName);
+    }
+
+    let isValue = null;
+    if (options && options.is !== undefined) {
+      isValue = options.is;
+    }
+
+    const namespace = this._parsingMode === "html" || this.contentType === "application/xhtml+xml" ? HTML_NS : null;
+
+    return createElement(this, localName, namespace, null, isValue, true);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-document-createelementns
+  createElementNS(namespace, qualifiedName, options) {
+    return internalCreateElementNSSteps(this, namespace, qualifiedName, options);
+  }
+
+  createDocumentFragment() {
+    return DocumentFragment.createImpl(this._globalObject, [], { ownerDocument: this });
+  }
+
+  createAttribute(localName) {
+    validateName(this._globalObject, localName);
+
+    if (this._parsingMode === "html") {
+      localName = asciiLowercase(localName);
+    }
+
+    return this._createAttribute({ localName });
+  }
+
+  createAttributeNS(namespace, name) {
+    if (namespace === undefined) {
+      namespace = null;
+    }
+    namespace = namespace !== null ? String(namespace) : namespace;
+
+    const extracted = validateAndExtract(this._globalObject, namespace, name);
+    return this._createAttribute({
+      namespace: extracted.namespace,
+      namespacePrefix: extracted.prefix,
+      localName: extracted.localName
+    });
+  }
+
+  // Using this helper function rather than directly calling generatedAttr.createImpl may be preferred in some files,
+  // to avoid introducing a potentially cyclic dependency on generated/Attr.js.
+  _createAttribute({
+    localName,
+    value,
+    namespace,
+    namespacePrefix
+  }) {
+    return generatedAttr.createImpl(this._globalObject, [], {
+      localName,
+      value,
+      namespace,
+      namespacePrefix,
+      ownerDocument: this
+    });
+  }
+
+  // TODO: Add callback interface support to `webidl2js`
+  createTreeWalker(root, whatToShow, filter) {
+    return TreeWalker.createImpl(this._globalObject, [], { root, whatToShow, filter });
+  }
+
+  createNodeIterator(root, whatToShow, filter) {
+    const nodeIterator = NodeIterator.createImpl(this._globalObject, [], { root, whatToShow, filter });
+
+    this._workingNodeIterators.push(nodeIterator);
+    while (this._workingNodeIterators.length > this._workingNodeIteratorsMax) {
+      const toInactivate = this._workingNodeIterators.shift();
+      toInactivate._working = false;
+    }
+
+    return nodeIterator;
+  }
+
+  importNode(node, deep) {
+    if (node.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot import a document node",
+        "NotSupportedError"
+      ]);
+    } else if (ShadowRoot.isImpl(node)) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot adopt a shadow root",
+        "NotSupportedError"
+      ]);
+    }
+
+    return clone(node, this, deep);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-document-adoptnode
+  adoptNode(node) {
+    if (node.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot adopt a document node",
+        "NotSupportedError"
+      ]);
+    } else if (ShadowRoot.isImpl(node)) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot adopt a shadow root",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    this._adoptNode(node);
+
+    return node;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-adopt
+  _adoptNode(node) {
+    const newDocument = this;
+    const oldDocument = node._ownerDocument;
+
+    const parent = domSymbolTree.parent(node);
+    if (parent) {
+      parent._remove(node);
+    }
+
+    if (oldDocument !== newDocument) {
+      for (const inclusiveDescendant of shadowIncludingInclusiveDescendantsIterator(node)) {
+        inclusiveDescendant._ownerDocument = newDocument;
+      }
+
+      for (const inclusiveDescendant of shadowIncludingInclusiveDescendantsIterator(node)) {
+        if (inclusiveDescendant._ceState === "custom") {
+          enqueueCECallbackReaction(inclusiveDescendant, "adoptedCallback", [
+            idlUtils.wrapperForImpl(oldDocument),
+            idlUtils.wrapperForImpl(newDocument)
+          ]);
+        }
+      }
+
+      for (const inclusiveDescendant of shadowIncludingInclusiveDescendantsIterator(node)) {
+        if (inclusiveDescendant._adoptingSteps) {
+          inclusiveDescendant._adoptingSteps(oldDocument);
+        }
+      }
+    }
+  }
+
+  get cookie() {
+    return this._cookieJar.getCookieStringSync(this.URL, { http: false });
+  }
+  set cookie(cookieStr) {
+    cookieStr = String(cookieStr);
+    this._cookieJar.setCookieSync(cookieStr, this.URL, {
+      http: false,
+      ignoreError: true
+    });
+  }
+
+  // The clear(), captureEvents(), and releaseEvents() methods must do nothing
+  clear() {}
+
+  captureEvents() {}
+
+  releaseEvents() {}
+
+  get styleSheets() {
+    if (!this._styleSheets) {
+      this._styleSheets = new StyleSheetList();
+    }
+
+    // TODO: each style and link element should register its sheet on creation
+    // and remove it on removal.
+    return this._styleSheets;
+  }
+
+  get hidden() {
+    if (this._defaultView && this._defaultView._pretendToBeVisual) {
+      return false;
+    }
+
+    return true;
+  }
+
+  get visibilityState() {
+    if (this._defaultView && this._defaultView._pretendToBeVisual) {
+      return "visible";
+    }
+
+    return "prerender";
+  }
+
+  // https://w3c.github.io/selection-api/#extensions-to-document-interface
+  getSelection() {
+    return this._defaultView ? this._defaultView._selection : null;
+  }
+}
+
+eventAccessors.createEventAccessor(DocumentImpl.prototype, "readystatechange");
+mixin(DocumentImpl.prototype, DocumentOrShadowRootImpl.prototype);
+mixin(DocumentImpl.prototype, GlobalEventHandlersImpl.prototype);
+mixin(DocumentImpl.prototype, NonElementParentNodeImpl.prototype);
+mixin(DocumentImpl.prototype, ParentNodeImpl.prototype);
+
+DocumentImpl.prototype.getElementsByTagName = memoizeQuery(function (qualifiedName) {
+  return listOfElementsWithQualifiedName(qualifiedName, this);
+});
+
+DocumentImpl.prototype.getElementsByTagNameNS = memoizeQuery(function (namespace, localName) {
+  return listOfElementsWithNamespaceAndLocalName(namespace, localName, this);
+});
+
+DocumentImpl.prototype.getElementsByClassName = memoizeQuery(function getElementsByClassName(classNames) {
+  return listOfElementsWithClassNames(classNames, this);
+});
+
+module.exports = {
+  implementation: DocumentImpl
+};
diff --git a/lib/jsdom/living/nodes/DocumentFragment-impl.js b/lib/jsdom/living/nodes/DocumentFragment-impl.js
new file mode 100644
index 0000000..a2a3870
--- /dev/null
+++ b/lib/jsdom/living/nodes/DocumentFragment-impl.js
@@ -0,0 +1,44 @@
+"use strict";
+const { mixin } = require("../../utils");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+const NodeImpl = require("./Node-impl").implementation;
+const NonElementParentNodeImpl = require("./NonElementParentNode-impl").implementation;
+const ParentNodeImpl = require("./ParentNode-impl").implementation;
+const idlUtils = require("../generated/utils");
+
+class DocumentFragmentImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, {
+      ownerDocument: idlUtils.implForWrapper(globalObject._document),
+      ...privateData
+    });
+
+    const { host } = privateData;
+    this._host = host;
+
+    this.nodeType = NODE_TYPE.DOCUMENT_FRAGMENT_NODE;
+  }
+
+  // This is implemented separately for Document (which has a _ids cache) and DocumentFragment (which does not).
+  getElementById(id) {
+    if (id === "") {
+      return null;
+    }
+
+    for (const descendant of domSymbolTree.treeIterator(this)) {
+      if (descendant.nodeType === NODE_TYPE.ELEMENT_NODE && descendant.getAttributeNS(null, "id") === id) {
+        return descendant;
+      }
+    }
+
+    return null;
+  }
+}
+
+mixin(DocumentFragmentImpl.prototype, NonElementParentNodeImpl.prototype);
+mixin(DocumentFragmentImpl.prototype, ParentNodeImpl.prototype);
+
+module.exports = {
+  implementation: DocumentFragmentImpl
+};
diff --git a/lib/jsdom/living/nodes/DocumentOrShadowRoot-impl.js b/lib/jsdom/living/nodes/DocumentOrShadowRoot-impl.js
new file mode 100644
index 0000000..4f85495
--- /dev/null
+++ b/lib/jsdom/living/nodes/DocumentOrShadowRoot-impl.js
@@ -0,0 +1,28 @@
+"use strict";
+const NODE_TYPE = require("../node-type");
+const { nodeRoot } = require("../helpers/node");
+const { retarget } = require("../helpers/shadow-dom");
+
+class DocumentOrShadowRootImpl {
+  get activeElement() {
+    let candidate = this._ownerDocument._lastFocusedElement || this._ownerDocument.body;
+    if (!candidate) {
+      return null;
+    }
+    candidate = retarget(candidate, this);
+    if (nodeRoot(candidate) !== this) {
+      return null;
+    }
+    if (candidate.nodeType !== NODE_TYPE.DOCUMENT_NODE) {
+      return candidate;
+    }
+    if (candidate.body !== null) {
+      return candidate.body;
+    }
+    return candidate.documentElement;
+  }
+}
+
+module.exports = {
+  implementation: DocumentOrShadowRootImpl
+};
diff --git a/lib/jsdom/living/nodes/DocumentType-impl.js b/lib/jsdom/living/nodes/DocumentType-impl.js
new file mode 100644
index 0000000..77767be
--- /dev/null
+++ b/lib/jsdom/living/nodes/DocumentType-impl.js
@@ -0,0 +1,24 @@
+"use strict";
+const { mixin } = require("../../utils");
+const NodeImpl = require("./Node-impl").implementation;
+const ChildNodeImpl = require("./ChildNode-impl").implementation;
+
+const NODE_TYPE = require("../node-type");
+
+class DocumentTypeImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.nodeType = NODE_TYPE.DOCUMENT_TYPE_NODE;
+
+    this.name = privateData.name;
+    this.publicId = privateData.publicId;
+    this.systemId = privateData.systemId;
+  }
+}
+
+mixin(DocumentTypeImpl.prototype, ChildNodeImpl.prototype);
+
+module.exports = {
+  implementation: DocumentTypeImpl
+};
diff --git a/lib/jsdom/living/nodes/Element-impl.js b/lib/jsdom/living/nodes/Element-impl.js
new file mode 100644
index 0000000..4b07e12
--- /dev/null
+++ b/lib/jsdom/living/nodes/Element-impl.js
@@ -0,0 +1,584 @@
+"use strict";
+const { addNwsapi } = require("../helpers/selectors");
+const { HTML_NS } = require("../helpers/namespaces");
+const { mixin, memoizeQuery } = require("../../utils");
+const idlUtils = require("../generated/utils");
+const NodeImpl = require("./Node-impl").implementation;
+const ParentNodeImpl = require("./ParentNode-impl").implementation;
+const ChildNodeImpl = require("./ChildNode-impl").implementation;
+const attributes = require("../attributes");
+const namedPropertiesWindow = require("../named-properties-window");
+const NODE_TYPE = require("../node-type");
+const { parseFragment } = require("../../browser/parser");
+const { fragmentSerialization } = require("../domparsing/serialization");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const DOMException = require("domexception/webidl2js-wrapper");
+const DOMTokenList = require("../generated/DOMTokenList");
+const NamedNodeMap = require("../generated/NamedNodeMap");
+const validateNames = require("../helpers/validate-names");
+const { asciiLowercase, asciiUppercase } = require("../helpers/strings");
+const { listOfElementsWithQualifiedName, listOfElementsWithNamespaceAndLocalName,
+  listOfElementsWithClassNames } = require("../node");
+const SlotableMixinImpl = require("./Slotable-impl").implementation;
+const NonDocumentTypeChildNode = require("./NonDocumentTypeChildNode-impl").implementation;
+const ShadowRoot = require("../generated/ShadowRoot");
+const Text = require("../generated/Text");
+const { isValidHostElementName } = require("../helpers/shadow-dom");
+const { isValidCustomElementName, lookupCEDefinition } = require("../helpers/custom-elements");
+
+function attachId(id, elm, doc) {
+  if (id && elm && doc) {
+    if (!doc._ids[id]) {
+      doc._ids[id] = [];
+    }
+    doc._ids[id].push(elm);
+  }
+}
+
+function detachId(id, elm, doc) {
+  if (id && elm && doc) {
+    if (doc._ids && doc._ids[id]) {
+      const elms = doc._ids[id];
+      for (let i = 0; i < elms.length; i++) {
+        if (elms[i] === elm) {
+          elms.splice(i, 1);
+          --i;
+        }
+      }
+      if (elms.length === 0) {
+        delete doc._ids[id];
+      }
+    }
+  }
+}
+
+class ElementImpl extends NodeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._initSlotableMixin();
+
+    this._namespaceURI = privateData.namespace;
+    this._prefix = privateData.prefix;
+    this._localName = privateData.localName;
+    this._ceState = privateData.ceState;
+    this._ceDefinition = privateData.ceDefinition;
+    this._isValue = privateData.isValue;
+
+    this._shadowRoot = null;
+    this._ceReactionQueue = [];
+
+    this.nodeType = NODE_TYPE.ELEMENT_NODE;
+    this.scrollTop = 0;
+    this.scrollLeft = 0;
+
+    this._attributeList = [];
+    // Used for caching.
+    this._attributesByNameMap = new Map();
+    this._attributes = NamedNodeMap.createImpl(this._globalObject, [], {
+      element: this
+    });
+  }
+
+  _attach() {
+    namedPropertiesWindow.nodeAttachedToDocument(this);
+
+    const id = this.getAttributeNS(null, "id");
+    if (id) {
+      attachId(id, this, this._ownerDocument);
+    }
+
+    super._attach();
+  }
+
+  _detach() {
+    super._detach();
+
+    namedPropertiesWindow.nodeDetachedFromDocument(this);
+
+    const id = this.getAttributeNS(null, "id");
+    if (id) {
+      detachId(id, this, this._ownerDocument);
+    }
+  }
+
+  _attrModified(name, value, oldValue) {
+    this._modified();
+    namedPropertiesWindow.elementAttributeModified(this, name, value, oldValue);
+
+    if (name === "id" && this._attached) {
+      const doc = this._ownerDocument;
+      detachId(oldValue, this, doc);
+      attachId(value, this, doc);
+    }
+
+    // update classList
+    if (name === "class" && this._classList !== undefined) {
+      this._classList.attrModified();
+    }
+
+    this._attrModifiedSlotableMixin(name, value, oldValue);
+  }
+
+  get namespaceURI() {
+    return this._namespaceURI;
+  }
+  get prefix() {
+    return this._prefix;
+  }
+  get localName() {
+    return this._localName;
+  }
+  get _qualifiedName() {
+    return this._prefix !== null ? this._prefix + ":" + this._localName : this._localName;
+  }
+  get tagName() {
+    let qualifiedName = this._qualifiedName;
+    if (this.namespaceURI === HTML_NS && this._ownerDocument._parsingMode === "html") {
+      qualifiedName = asciiUppercase(qualifiedName);
+    }
+    return qualifiedName;
+  }
+
+  get attributes() {
+    return this._attributes;
+  }
+
+  // https://w3c.github.io/DOM-Parsing/#dom-element-outerhtml
+  get outerHTML() {
+    // TODO: maybe parse5 can give us a hook where it serializes the node itself too:
+    // https://github.com/inikulin/parse5/issues/230
+    // Alternatively, if we can create a virtual node in domSymbolTree, that'd also work.
+    // It's currently prevented by the fact that a node can't be duplicated in the same tree.
+    // Then we could get rid of all the code for childNodesForSerializing.
+    return fragmentSerialization({ childNodesForSerializing: [this], _ownerDocument: this._ownerDocument }, {
+      requireWellFormed: true,
+      globalObject: this._globalObject
+    });
+  }
+  set outerHTML(markup) {
+    let parent = domSymbolTree.parent(this);
+    const document = this._ownerDocument;
+
+    if (!parent) {
+      return;
+    }
+
+    if (parent.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+      throw DOMException.create(this._globalObject, [
+        "Modifications are not allowed for this document",
+        "NoModificationAllowedError"
+      ]);
+    }
+
+    if (parent.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE) {
+      parent = document.createElementNS(HTML_NS, "body");
+    }
+
+    const fragment = parseFragment(markup, parent);
+
+    const contextObjectParent = domSymbolTree.parent(this);
+    contextObjectParent._replace(fragment, this);
+  }
+
+  // https://w3c.github.io/DOM-Parsing/#dfn-innerhtml
+  get innerHTML() {
+    return fragmentSerialization(this, {
+      requireWellFormed: true,
+      globalObject: this._globalObject
+    });
+  }
+  set innerHTML(markup) {
+    const fragment = parseFragment(markup, this);
+
+    let contextObject = this;
+    if (this.localName === "template" && this.namespaceURI === HTML_NS) {
+      contextObject = contextObject._templateContents;
+    }
+
+    contextObject._replaceAll(fragment);
+  }
+
+  get classList() {
+    if (this._classList === undefined) {
+      this._classList = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "class"
+      });
+    }
+    return this._classList;
+  }
+
+  hasAttributes() {
+    return attributes.hasAttributes(this);
+  }
+
+  getAttributeNames() {
+    return attributes.attributeNames(this);
+  }
+
+  getAttribute(name) {
+    const attr = attributes.getAttributeByName(this, name);
+    if (!attr) {
+      return null;
+    }
+    return attr._value;
+  }
+
+  getAttributeNS(namespace, localName) {
+    const attr = attributes.getAttributeByNameNS(this, namespace, localName);
+    if (!attr) {
+      return null;
+    }
+    return attr._value;
+  }
+
+  setAttribute(name, value) {
+    validateNames.name(this._globalObject, name);
+
+    if (this._namespaceURI === HTML_NS && this._ownerDocument._parsingMode === "html") {
+      name = asciiLowercase(name);
+    }
+
+    const attribute = attributes.getAttributeByName(this, name);
+
+    if (attribute === null) {
+      const newAttr = this._ownerDocument._createAttribute({
+        localName: name,
+        value
+      });
+      attributes.appendAttribute(this, newAttr);
+      return;
+    }
+
+    attributes.changeAttribute(this, attribute, value);
+  }
+
+  setAttributeNS(namespace, name, value) {
+    const extracted = validateNames.validateAndExtract(this._globalObject, namespace, name);
+
+    // Because of widespread use of this method internally, e.g. to manually implement attribute/content reflection, we
+    // centralize the conversion to a string here, so that all call sites don't have to do it.
+    value = `${value}`;
+
+    attributes.setAttributeValue(this, extracted.localName, value, extracted.prefix, extracted.namespace);
+  }
+
+  removeAttribute(name) {
+    attributes.removeAttributeByName(this, name);
+  }
+
+  removeAttributeNS(namespace, localName) {
+    attributes.removeAttributeByNameNS(this, namespace, localName);
+  }
+
+  toggleAttribute(qualifiedName, force) {
+    validateNames.name(this._globalObject, qualifiedName);
+
+    if (this._namespaceURI === HTML_NS && this._ownerDocument._parsingMode === "html") {
+      qualifiedName = asciiLowercase(qualifiedName);
+    }
+
+    const attribute = attributes.getAttributeByName(this, qualifiedName);
+
+    if (attribute === null) {
+      if (force === undefined || force === true) {
+        const newAttr = this._ownerDocument._createAttribute({
+          localName: qualifiedName,
+          value: ""
+        });
+        attributes.appendAttribute(this, newAttr);
+        return true;
+      }
+      return false;
+    }
+
+    if (force === undefined || force === false) {
+      attributes.removeAttributeByName(this, qualifiedName);
+      return false;
+    }
+
+    return true;
+  }
+
+  hasAttribute(name) {
+    if (this._namespaceURI === HTML_NS && this._ownerDocument._parsingMode === "html") {
+      name = asciiLowercase(name);
+    }
+
+    return attributes.hasAttributeByName(this, name);
+  }
+
+  hasAttributeNS(namespace, localName) {
+    if (namespace === "") {
+      namespace = null;
+    }
+
+    return attributes.hasAttributeByNameNS(this, namespace, localName);
+  }
+
+  getAttributeNode(name) {
+    return attributes.getAttributeByName(this, name);
+  }
+
+  getAttributeNodeNS(namespace, localName) {
+    return attributes.getAttributeByNameNS(this, namespace, localName);
+  }
+
+  setAttributeNode(attr) {
+    // eslint-disable-next-line no-restricted-properties
+    return attributes.setAttribute(this, attr);
+  }
+
+  setAttributeNodeNS(attr) {
+    // eslint-disable-next-line no-restricted-properties
+    return attributes.setAttribute(this, attr);
+  }
+
+  removeAttributeNode(attr) {
+    // eslint-disable-next-line no-restricted-properties
+    if (!attributes.hasAttribute(this, attr)) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to remove an attribute that was not present",
+        "NotFoundError"
+      ]);
+    }
+
+    // eslint-disable-next-line no-restricted-properties
+    attributes.removeAttribute(this, attr);
+
+    return attr;
+  }
+
+  getBoundingClientRect() {
+    return {
+      bottom: 0,
+      height: 0,
+      left: 0,
+      right: 0,
+      top: 0,
+      width: 0
+    };
+  }
+
+  getClientRects() {
+    return [];
+  }
+
+  get scrollWidth() {
+    return 0;
+  }
+
+  get scrollHeight() {
+    return 0;
+  }
+
+  get clientTop() {
+    return 0;
+  }
+
+  get clientLeft() {
+    return 0;
+  }
+
+  get clientWidth() {
+    return 0;
+  }
+
+  get clientHeight() {
+    return 0;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-element-attachshadow
+  attachShadow(init) {
+    const { _ownerDocument, _namespaceURI, _localName, _isValue } = this;
+
+    if (this.namespaceURI !== HTML_NS) {
+      throw DOMException.create(this._globalObject, [
+        "This element does not support attachShadow. This element is not part of the HTML namespace.",
+        "NotSupportedError"
+      ]);
+    }
+
+    if (!isValidHostElementName(_localName) && !isValidCustomElementName(_localName)) {
+      const message = "This element does not support attachShadow. This element is not a custom element nor " +
+        "a standard element supporting a shadow root.";
+      throw DOMException.create(this._globalObject, [message, "NotSupportedError"]);
+    }
+
+    if (isValidCustomElementName(_localName) || _isValue) {
+      const definition = lookupCEDefinition(_ownerDocument, _namespaceURI, _localName, _isValue);
+
+      if (definition && definition.disableShadow) {
+        throw DOMException.create(this._globalObject, [
+          "Shadow root cannot be create on a custom element with disabled shadow",
+          "NotSupportedError"
+        ]);
+      }
+    }
+
+    if (this._shadowRoot !== null) {
+      throw DOMException.create(this._globalObject, [
+        "Shadow root cannot be created on a host which already hosts a shadow tree.",
+        "NotSupportedError"
+      ]);
+    }
+
+    const shadow = ShadowRoot.createImpl(this._globalObject, [], {
+      ownerDocument: this.ownerDocument,
+      mode: init.mode,
+      host: this
+    });
+
+    this._shadowRoot = shadow;
+
+    return shadow;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-element-shadowroot
+  get shadowRoot() {
+    const shadow = this._shadowRoot;
+
+    if (shadow === null || shadow.mode === "closed") {
+      return null;
+    }
+
+    return shadow;
+  }
+
+  // https://dom.spec.whatwg.org/#insert-adjacent
+  _insertAdjacent(element, where, node) {
+    where = asciiLowercase(where);
+
+    if (where === "beforebegin") {
+      if (element.parentNode === null) {
+        return null;
+      }
+      return element.parentNode._preInsert(node, element);
+    }
+    if (where === "afterbegin") {
+      return element._preInsert(node, element.firstChild);
+    }
+    if (where === "beforeend") {
+      return element._preInsert(node, null);
+    }
+    if (where === "afterend") {
+      if (element.parentNode === null) {
+        return null;
+      }
+      return element.parentNode._preInsert(node, element.nextSibling);
+    }
+
+    throw DOMException.create(this._globalObject, [
+      'Must provide one of "beforebegin", "afterbegin", "beforeend", or "afterend".',
+      "SyntaxError"
+    ]);
+  }
+
+  insertAdjacentElement(where, element) {
+    return this._insertAdjacent(this, where, element);
+  }
+
+  insertAdjacentText(where, data) {
+    const text = Text.createImpl(this._globalObject, [], { data, ownerDocument: this._ownerDocument });
+
+    this._insertAdjacent(this, where, text);
+  }
+
+  // https://w3c.github.io/DOM-Parsing/#dom-element-insertadjacenthtml
+  insertAdjacentHTML(position, text) {
+    position = asciiLowercase(position);
+
+    let context;
+    switch (position) {
+      case "beforebegin":
+      case "afterend": {
+        context = this.parentNode;
+        if (context === null || context.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+          throw DOMException.create(this._globalObject, [
+            "Cannot insert HTML adjacent to parent-less nodes or children of document nodes.",
+            "NoModificationAllowedError"
+          ]);
+        }
+        break;
+      }
+      case "afterbegin":
+      case "beforeend": {
+        context = this;
+        break;
+      }
+      default: {
+        throw DOMException.create(this._globalObject, [
+          'Must provide one of "beforebegin", "afterbegin", "beforeend", or "afterend".',
+          "SyntaxError"
+        ]);
+      }
+    }
+
+    if (
+      context.nodeType !== NODE_TYPE.ELEMENT_NODE ||
+      (
+        context._ownerDocument._parsingMode === "html" &&
+        context._localName === "html" &&
+        context._namespaceURI === HTML_NS
+      )
+    ) {
+      context = context._ownerDocument.createElement("body");
+    }
+
+    const fragment = parseFragment(text, context);
+
+    switch (position) {
+      case "beforebegin": {
+        this.parentNode._insert(fragment, this);
+        break;
+      }
+      case "afterbegin": {
+        this._insert(fragment, this.firstChild);
+        break;
+      }
+      case "beforeend": {
+        this._append(fragment);
+        break;
+      }
+      case "afterend": {
+        this.parentNode._insert(fragment, this.nextSibling);
+        break;
+      }
+    }
+  }
+
+  closest(selectors) {
+    const matcher = addNwsapi(this);
+    return matcher.closest(selectors, idlUtils.wrapperForImpl(this));
+  }
+}
+
+mixin(ElementImpl.prototype, NonDocumentTypeChildNode.prototype);
+mixin(ElementImpl.prototype, ParentNodeImpl.prototype);
+mixin(ElementImpl.prototype, ChildNodeImpl.prototype);
+mixin(ElementImpl.prototype, SlotableMixinImpl.prototype);
+
+ElementImpl.prototype.getElementsByTagName = memoizeQuery(function (qualifiedName) {
+  return listOfElementsWithQualifiedName(qualifiedName, this);
+});
+
+ElementImpl.prototype.getElementsByTagNameNS = memoizeQuery(function (namespace, localName) {
+  return listOfElementsWithNamespaceAndLocalName(namespace, localName, this);
+});
+
+ElementImpl.prototype.getElementsByClassName = memoizeQuery(function (classNames) {
+  return listOfElementsWithClassNames(classNames, this);
+});
+
+ElementImpl.prototype.matches = function (selectors) {
+  const matcher = addNwsapi(this);
+
+  return matcher.match(selectors, idlUtils.wrapperForImpl(this));
+};
+
+ElementImpl.prototype.webkitMatchesSelector = ElementImpl.prototype.matches;
+
+module.exports = {
+  implementation: ElementImpl
+};
diff --git a/lib/jsdom/living/nodes/ElementCSSInlineStyle-impl.js b/lib/jsdom/living/nodes/ElementCSSInlineStyle-impl.js
new file mode 100644
index 0000000..66d685d
--- /dev/null
+++ b/lib/jsdom/living/nodes/ElementCSSInlineStyle-impl.js
@@ -0,0 +1,25 @@
+"use strict";
+const cssstyle = require("cssstyle");
+
+class ElementCSSInlineStyle {
+  _initElementCSSInlineStyle() {
+    this._settingCssText = false;
+    this._style = new cssstyle.CSSStyleDeclaration(newCssText => {
+      if (!this._settingCssText) {
+        this._settingCssText = true;
+        this.setAttributeNS(null, "style", newCssText);
+        this._settingCssText = false;
+      }
+    });
+  }
+  get style() {
+    return this._style;
+  }
+  set style(value) {
+    this._style.cssText = value;
+  }
+}
+
+module.exports = {
+  implementation: ElementCSSInlineStyle
+};
diff --git a/lib/jsdom/living/nodes/ElementContentEditable-impl.js b/lib/jsdom/living/nodes/ElementContentEditable-impl.js
new file mode 100644
index 0000000..8523c9c
--- /dev/null
+++ b/lib/jsdom/living/nodes/ElementContentEditable-impl.js
@@ -0,0 +1,7 @@
+"use strict";
+
+class ElementContentEditableImpl { }
+
+module.exports = {
+  implementation: ElementContentEditableImpl
+};
diff --git a/lib/jsdom/living/nodes/GlobalEventHandlers-impl.js b/lib/jsdom/living/nodes/GlobalEventHandlers-impl.js
new file mode 100644
index 0000000..483463b
--- /dev/null
+++ b/lib/jsdom/living/nodes/GlobalEventHandlers-impl.js
@@ -0,0 +1,95 @@
+"use strict";
+
+const { appendHandler, createEventAccessor } = require("../helpers/create-event-accessor");
+
+const events = new Set([
+  "abort", "autocomplete",
+  "autocompleteerror", "blur",
+  "cancel", "canplay", "canplaythrough",
+  "change", "click",
+  "close", "contextmenu",
+  "cuechange", "dblclick",
+  "drag", "dragend",
+  "dragenter", "dragexit",
+  "dragleave", "dragover",
+  "dragstart", "drop",
+  "durationchange", "emptied",
+  "ended", "error", "focus",
+  "input", "invalid",
+  "keydown", "keypress",
+  "keyup", "load", "loadeddata",
+  "loadedmetadata", "loadstart",
+  "mousedown", "mouseenter",
+  "mouseleave", "mousemove",
+  "mouseout", "mouseover",
+  "mouseup", "wheel",
+  "pause", "play",
+  "playing", "progress",
+  "ratechange", "reset",
+  "resize", "scroll",
+  "securitypolicyviolation",
+  "seeked", "seeking",
+  "select", "sort", "stalled",
+  "submit", "suspend",
+  "timeupdate", "toggle",
+  "volumechange", "waiting"
+]);
+
+class GlobalEventHandlersImpl {
+  _initGlobalEvents() {
+    this._registeredHandlers = new Set();
+    this._eventHandlers = Object.create(null);
+  }
+
+  _getEventHandlerTarget() {
+    return this;
+  }
+
+  _getEventHandlerFor(event) {
+    const target = this._getEventHandlerTarget(event);
+    if (!target) {
+      return null;
+    }
+
+    return target._eventHandlers[event];
+  }
+
+  _setEventHandlerFor(event, handler) {
+    const target = this._getEventHandlerTarget(event);
+    if (!target) {
+      return;
+    }
+
+    if (!target._registeredHandlers.has(event) && handler !== null) {
+      target._registeredHandlers.add(event);
+      appendHandler(target, event);
+    }
+    target._eventHandlers[event] = handler;
+  }
+
+  _globalEventChanged(event) {
+    const propName = "on" + event;
+    if (!(propName in this)) {
+      return;
+    }
+
+    // Only translate attribute changes into properties when runScripts: "dangerously" is set.
+    // Documents without a browsing context (i.e. without a _defaultView) never run scripts.
+    const runScripts = "_runScripts" in this ? this._runScripts : (this._ownerDocument._defaultView || {})._runScripts;
+    if (runScripts !== "dangerously") {
+      return;
+    }
+
+    const val = this.getAttributeNS(null, propName);
+    const handler = val === null ? null : { body: val };
+    this._setEventHandlerFor(event, handler);
+  }
+}
+
+for (const event of events) {
+  createEventAccessor(GlobalEventHandlersImpl.prototype, event);
+}
+
+module.exports = {
+  implementation: GlobalEventHandlersImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLAnchorElement-impl.js b/lib/jsdom/living/nodes/HTMLAnchorElement-impl.js
new file mode 100644
index 0000000..73b6943
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLAnchorElement-impl.js
@@ -0,0 +1,50 @@
+"use strict";
+const { mixin } = require("../../utils");
+const DOMTokenList = require("../generated/DOMTokenList");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const HTMLHyperlinkElementUtilsImpl = require("./HTMLHyperlinkElementUtils-impl").implementation;
+
+class HTMLAnchorElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._htmlHyperlinkElementUtilsSetup();
+
+    this._hasActivationBehavior = true;
+  }
+
+  _activationBehavior() {
+    this._followAHyperlink();
+  }
+
+  get relList() {
+    if (this._relList === undefined) {
+      this._relList = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "rel"
+      });
+    }
+    return this._relList;
+  }
+
+  get text() {
+    return this.textContent;
+  }
+  set text(v) {
+    this.textContent = v;
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "rel" && this._relList !== undefined) {
+      this._relList.attrModified();
+    }
+  }
+}
+
+mixin(HTMLAnchorElementImpl.prototype, HTMLHyperlinkElementUtilsImpl.prototype);
+
+module.exports = {
+  implementation: HTMLAnchorElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLAreaElement-impl.js b/lib/jsdom/living/nodes/HTMLAreaElement-impl.js
new file mode 100644
index 0000000..58d5fe1
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLAreaElement-impl.js
@@ -0,0 +1,43 @@
+"use strict";
+const { mixin } = require("../../utils");
+const DOMTokenList = require("../generated/DOMTokenList");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const HTMLHyperlinkElementUtilsImpl = require("./HTMLHyperlinkElementUtils-impl").implementation;
+
+class HTMLAreaElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._htmlHyperlinkElementUtilsSetup();
+
+    this._hasActivationBehavior = true;
+  }
+
+  _activationBehavior() {
+    this._followAHyperlink();
+  }
+
+  get relList() {
+    if (this._relList === undefined) {
+      this._relList = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "rel"
+      });
+    }
+    return this._relList;
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "rel" && this._relList !== undefined) {
+      this._relList.attrModified();
+    }
+  }
+}
+
+mixin(HTMLAreaElementImpl.prototype, HTMLHyperlinkElementUtilsImpl.prototype);
+
+module.exports = {
+  implementation: HTMLAreaElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLAudioElement-impl.js b/lib/jsdom/living/nodes/HTMLAudioElement-impl.js
new file mode 100644
index 0000000..ad65ff5
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLAudioElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLMediaElementImpl = require("./HTMLMediaElement-impl").implementation;
+
+class HTMLAudioElementImpl extends HTMLMediaElementImpl { }
+
+module.exports = {
+  implementation: HTMLAudioElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLBRElement-impl.js b/lib/jsdom/living/nodes/HTMLBRElement-impl.js
new file mode 100644
index 0000000..c921613
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLBRElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLBRElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLBRElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLBaseElement-impl.js b/lib/jsdom/living/nodes/HTMLBaseElement-impl.js
new file mode 100644
index 0000000..ece7d83
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLBaseElement-impl.js
@@ -0,0 +1,27 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { fallbackBaseURL } = require("../helpers/document-base-url");
+
+class HTMLBaseElementImpl extends HTMLElementImpl {
+  get href() {
+    const document = this._ownerDocument;
+
+    const url = this.hasAttributeNS(null, "href") ? this.getAttributeNS(null, "href") : "";
+    const parsed = whatwgURL.parseURL(url, { baseURL: fallbackBaseURL(document) });
+
+    if (parsed === null) {
+      return url;
+    }
+
+    return whatwgURL.serializeURL(parsed);
+  }
+
+  set href(value) {
+    this.setAttributeNS(null, "href", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLBaseElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLBodyElement-impl.js b/lib/jsdom/living/nodes/HTMLBodyElement-impl.js
new file mode 100644
index 0000000..1ebd0ea
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLBodyElement-impl.js
@@ -0,0 +1,17 @@
+"use strict";
+const { mixin } = require("../../utils");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const WindowEventHandlersImpl = require("./WindowEventHandlers-impl").implementation;
+
+class HTMLBodyElementImpl extends HTMLElementImpl {
+  constructor(...args) {
+    super(...args);
+    this._proxyWindowEventsToWindow();
+  }
+}
+
+mixin(HTMLBodyElementImpl.prototype, WindowEventHandlersImpl.prototype);
+
+module.exports = {
+  implementation: HTMLBodyElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLButtonElement-impl.js b/lib/jsdom/living/nodes/HTMLButtonElement-impl.js
new file mode 100644
index 0000000..ba5a0cb
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLButtonElement-impl.js
@@ -0,0 +1,79 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { isDisabled, formOwner } = require("../helpers/form-controls");
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { mixin } = require("../../utils");
+const { getLabelsForLabelable } = require("../helpers/form-controls");
+
+class HTMLButtonElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._customValidityErrorMessage = "";
+    this._labels = null;
+
+    this._hasActivationBehavior = true;
+  }
+
+  _activationBehavior() {
+    const { form } = this;
+    if (form && !isDisabled(this)) {
+      if (this.type === "submit") {
+        form._doSubmit();
+      }
+      if (this.type === "reset") {
+        form._doReset();
+      }
+    }
+  }
+
+  _getValue() {
+    const valueAttr = this.getAttributeNS(null, "value");
+    return valueAttr === null ? "" : valueAttr;
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get type() {
+    const typeAttr = (this.getAttributeNS(null, "type") || "").toLowerCase();
+    switch (typeAttr) {
+      case "submit":
+      case "reset":
+      case "button":
+        return typeAttr;
+      default:
+        return "submit";
+    }
+  }
+
+  set type(v) {
+    v = String(v).toLowerCase();
+    switch (v) {
+      case "submit":
+      case "reset":
+      case "button":
+        this.setAttributeNS(null, "type", v);
+        break;
+      default:
+        this.setAttributeNS(null, "type", "submit");
+        break;
+    }
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return this.type === "reset" || this.type === "button";
+  }
+}
+
+mixin(HTMLButtonElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLButtonElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLCanvasElement-impl.js b/lib/jsdom/living/nodes/HTMLCanvasElement-impl.js
new file mode 100644
index 0000000..2435aab
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLCanvasElement-impl.js
@@ -0,0 +1,127 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const notImplemented = require("../../browser/not-implemented");
+const idlUtils = require("../generated/utils");
+const { Canvas } = require("../../utils");
+
+class HTMLCanvasElementImpl extends HTMLElementImpl {
+  _attrModified(name, value) {
+    if (this._canvas && (name === "width" || name === "height")) {
+      this._canvas[name] = parseInt(value);
+    }
+
+    super._attrModified.apply(this, arguments);
+  }
+
+  _getCanvas() {
+    if (Canvas && !this._canvas) {
+      this._canvas = Canvas.createCanvas(this.width, this.height);
+    }
+    return this._canvas;
+  }
+
+  getContext(contextId) {
+    const canvas = this._getCanvas();
+    if (canvas) {
+      if (!this._context) {
+        this._context = canvas.getContext(contextId) || null;
+        if (this._context) {
+          // Override the native canvas reference with our wrapper. This is the
+          // reason why we need to locally cache _context, since each call to
+          // canvas.getContext(contextId) would replace this reference again.
+          // Perhaps in the longer term, a better solution would be to create a
+          // full wrapper for the Context object as well.
+          this._context.canvas = idlUtils.wrapperForImpl(this);
+          wrapNodeCanvasMethod(this._context, "createPattern");
+          wrapNodeCanvasMethod(this._context, "drawImage");
+        }
+      }
+      return this._context;
+    }
+
+    notImplemented(
+      "HTMLCanvasElement.prototype.getContext (without installing the canvas npm package)",
+      this._ownerDocument._defaultView
+    );
+    return null;
+  }
+
+  toDataURL() {
+    const canvas = this._getCanvas();
+    if (canvas) {
+      return canvas.toDataURL.apply(this._canvas, arguments);
+    }
+
+    notImplemented(
+      "HTMLCanvasElement.prototype.toDataURL (without installing the canvas npm package)",
+      this._ownerDocument._defaultView
+    );
+    return null;
+  }
+
+  toBlob(callback, type, qualityArgument) {
+    const window = this._ownerDocument._defaultView;
+    const canvas = this._getCanvas();
+    if (canvas) {
+      const options = {};
+      switch (type) {
+        case "image/jpg":
+        case "image/jpeg":
+          type = "image/jpeg";
+          options.quality = qualityArgument;
+          break;
+        default:
+          type = "image/png";
+      }
+      canvas.toBuffer((err, buff) => {
+        if (err) {
+          throw err;
+        }
+        callback(new window.Blob([buff], { type }));
+      }, type, options);
+    } else {
+      notImplemented(
+        "HTMLCanvasElement.prototype.toBlob (without installing the canvas npm package)",
+        window
+      );
+    }
+  }
+
+  get width() {
+    const parsed = parseInt(this.getAttributeNS(null, "width"));
+    return isNaN(parsed) || parsed < 0 || parsed > 2147483647 ? 300 : parsed;
+  }
+
+  set width(v) {
+    v = v > 2147483647 ? 300 : v;
+    this.setAttributeNS(null, "width", String(v));
+  }
+
+  get height() {
+    const parsed = parseInt(this.getAttributeNS(null, "height"));
+    return isNaN(parsed) || parsed < 0 || parsed > 2147483647 ? 150 : parsed;
+  }
+
+  set height(v) {
+    v = v > 2147483647 ? 150 : v;
+    this.setAttributeNS(null, "height", String(v));
+  }
+}
+
+// We need to wrap the methods that receive an image or canvas object
+// (luckily, always as the first argument), so that these objects can be
+// unwrapped an the expected types passed.
+function wrapNodeCanvasMethod(ctx, name) {
+  const prev = ctx[name];
+  ctx[name] = function (image) {
+    const impl = idlUtils.implForWrapper(image);
+    if (impl) {
+      arguments[0] = impl._image || impl._canvas;
+    }
+    return prev.apply(ctx, arguments);
+  };
+}
+
+module.exports = {
+  implementation: HTMLCanvasElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLCollection-impl.js b/lib/jsdom/living/nodes/HTMLCollection-impl.js
new file mode 100644
index 0000000..980ebd2
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLCollection-impl.js
@@ -0,0 +1,96 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+const { HTML_NS } = require("../helpers/namespaces");
+
+exports.implementation = class HTMLCollectionImpl {
+  constructor(globalObject, args, privateData) {
+    this._list = [];
+    this._version = -1;
+    this._element = privateData.element;
+    this._query = privateData.query;
+
+    this._globalObject = globalObject;
+
+    this._update();
+  }
+  get length() {
+    this._update();
+    return this._list.length;
+  }
+  item(index) {
+    this._update();
+    return this._list[index] || null;
+  }
+  namedItem(key) {
+    if (key === "") {
+      return null;
+    }
+    this._update();
+    for (const element of this._list) {
+      if (element.getAttributeNS(null, "id") === key) {
+        return element;
+      }
+      if (element._namespaceURI === HTML_NS) {
+        const name = element.getAttributeNS(null, "name");
+        if (name === key) {
+          return element;
+        }
+      }
+    }
+    return null;
+  }
+  _update() {
+    if (this._version < this._element._version) {
+      const snapshot = this._query();
+      for (let i = 0; i < snapshot.length; i++) {
+        this._list[i] = snapshot[i];
+      }
+      this._list.length = snapshot.length;
+      this._version = this._element._version;
+    }
+  }
+  get [idlUtils.supportedPropertyIndices]() {
+    this._update();
+    return this._list.keys();
+  }
+  get [idlUtils.supportedPropertyNames]() {
+    this._update();
+    const result = new Set();
+    for (const element of this._list) {
+      const id = element.getAttributeNS(null, "id");
+      if (id) {
+        result.add(id);
+      }
+      if (element._namespaceURI === HTML_NS) {
+        const name = element.getAttributeNS(null, "name");
+        if (name) {
+          result.add(name);
+        }
+      }
+    }
+    return result;
+  }
+
+  // Inherit some useful functions from Array.
+  [Symbol.iterator]() {
+    this._update();
+    return this._list[Symbol.iterator]();
+  }
+  entries() {
+    this._update();
+    return this._list.entries();
+  }
+  filter(...args) {
+    this._update();
+    return this._list.filter(...args);
+  }
+  map(...args) {
+    this._update();
+    return this._list.map(...args);
+  }
+  indexOf(...args) {
+    this._update();
+    return this._list.indexOf(...args);
+  }
+};
diff --git a/lib/jsdom/living/nodes/HTMLDListElement-impl.js b/lib/jsdom/living/nodes/HTMLDListElement-impl.js
new file mode 100644
index 0000000..22ee9bd
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDListElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDListElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDListElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLDataElement-impl.js b/lib/jsdom/living/nodes/HTMLDataElement-impl.js
new file mode 100644
index 0000000..2d75abc
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDataElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDataElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDataElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLDataListElement-impl.js b/lib/jsdom/living/nodes/HTMLDataListElement-impl.js
new file mode 100644
index 0000000..ccd2c4c
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDataListElement-impl.js
@@ -0,0 +1,20 @@
+"use strict";
+
+const HTMLCollection = require("../generated/HTMLCollection");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const { descendantsByLocalName } = require("../helpers/traversal");
+
+class HTMLDataListElementImpl extends HTMLElementImpl {
+  // https://html.spec.whatwg.org/multipage/form-elements.html#dom-datalist-options
+  get options() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => descendantsByLocalName(this, "option")
+    });
+  }
+}
+
+module.exports = {
+  implementation: HTMLDataListElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLDetailsElement-impl.js b/lib/jsdom/living/nodes/HTMLDetailsElement-impl.js
new file mode 100644
index 0000000..7a934b4
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDetailsElement-impl.js
@@ -0,0 +1,35 @@
+"use strict";
+
+const { fireAnEvent } = require("../helpers/events");
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDetailsElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._taskQueue = null;
+  }
+
+  _dispatchToggleEvent() {
+    this._taskQueue = null;
+
+    fireAnEvent("toggle", this);
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "open" && this._taskQueue === null) {
+      // Check that the attribute is added or removed, not merely changed
+      if ((value !== oldValue && value !== null && oldValue === null) ||
+          (value === null && oldValue !== null)) {
+        this._taskQueue = setTimeout(this._dispatchToggleEvent.bind(this), 0);
+      }
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLDetailsElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLDialogElement-impl.js b/lib/jsdom/living/nodes/HTMLDialogElement-impl.js
new file mode 100644
index 0000000..d020e3c
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDialogElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDialogElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDialogElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLDirectoryElement-impl.js b/lib/jsdom/living/nodes/HTMLDirectoryElement-impl.js
new file mode 100644
index 0000000..ea05eb3
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDirectoryElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDirectoryElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDirectoryElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLDivElement-impl.js b/lib/jsdom/living/nodes/HTMLDivElement-impl.js
new file mode 100644
index 0000000..b81a714
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLDivElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLDivElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLDivElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLElement-impl.js b/lib/jsdom/living/nodes/HTMLElement-impl.js
new file mode 100644
index 0000000..89d5531
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLElement-impl.js
@@ -0,0 +1,158 @@
+"use strict";
+const { mixin } = require("../../utils");
+const ElementImpl = require("./Element-impl").implementation;
+const MouseEvent = require("../generated/MouseEvent");
+const ElementCSSInlineStyleImpl = require("./ElementCSSInlineStyle-impl").implementation;
+const GlobalEventHandlersImpl = require("./GlobalEventHandlers-impl").implementation;
+const HTMLOrSVGElementImpl = require("./HTMLOrSVGElement-impl").implementation;
+const { firstChildWithLocalName } = require("../helpers/traversal");
+const { isDisabled } = require("../helpers/form-controls");
+const { fireAnEvent } = require("../helpers/events");
+
+class HTMLElementImpl extends ElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._initHTMLOrSVGElement();
+    this._initElementCSSInlineStyle();
+    this._initGlobalEvents();
+
+    this._clickInProgress = false;
+
+    // <summary> uses HTMLElement and has activation behavior
+    this._hasActivationBehavior = this._localName === "summary";
+  }
+
+  _activationBehavior() {
+    const parent = this.parentNode;
+    if (parent && parent._localName === "details" &&
+        this === firstChildWithLocalName(parent, "summary")) {
+      if (parent.hasAttributeNS(null, "open")) {
+        parent.removeAttributeNS(null, "open");
+      } else {
+        parent.setAttributeNS(null, "open", "");
+      }
+    }
+  }
+
+  // https://html.spec.whatwg.org/multipage/dom.html#the-translate-attribute
+  get translate() {
+    const translateAttr = this.getAttributeNS(null, "translate");
+
+    if (translateAttr === "yes" || translateAttr === "") {
+      return true;
+    } else if (translateAttr === "no") {
+      return false;
+    }
+
+    if (this === this.ownerDocument.documentElement) {
+      return true;
+    }
+
+    return this.parentElement && this.parentElement.translate;
+  }
+  set translate(value) {
+    if (value === true) {
+      this.setAttributeNS(null, "translate", "yes");
+    } else {
+      this.setAttributeNS(null, "translate", "no");
+    }
+  }
+
+  click() {
+    // https://html.spec.whatwg.org/multipage/interaction.html#dom-click
+    // https://html.spec.whatwg.org/multipage/webappapis.html#fire-a-synthetic-mouse-event
+
+    if (isDisabled(this)) {
+      return;
+    }
+
+    if (this._clickInProgress) {
+      return;
+    }
+
+    this._clickInProgress = true;
+
+    // https://github.com/whatwg/html/issues/4451
+    // https://github.com/whatwg/html/issues/4452
+    fireAnEvent("click", this, MouseEvent, {
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+      isTrusted: false,
+      view: this.ownerDocument.defaultView
+    });
+
+    this._clickInProgress = false;
+  }
+
+  get draggable() {
+    const attributeValue = this.getAttributeNS(null, "draggable");
+
+    if (attributeValue === "true") {
+      return true;
+    } else if (attributeValue === "false") {
+      return false;
+    }
+
+    return this._localName === "img" || (this._localName === "a" && this.hasAttributeNS(null, "href"));
+  }
+  set draggable(value) {
+    this.setAttributeNS(null, "draggable", String(value));
+  }
+
+  get dir() {
+    let dirValue = this.getAttributeNS(null, "dir");
+    if (dirValue !== null) {
+      dirValue = dirValue.toLowerCase();
+
+      if (["ltr", "rtl", "auto"].includes(dirValue)) {
+        return dirValue;
+      }
+    }
+    return "";
+  }
+  set dir(value) {
+    this.setAttributeNS(null, "dir", value);
+  }
+
+  // Keep in sync with SVGElement. https://github.com/jsdom/jsdom/issues/2599
+  _attrModified(name, value, oldValue) {
+    if (name === "style" && value !== oldValue && !this._settingCssText) {
+      this._settingCssText = true;
+      this._style.cssText = value;
+      this._settingCssText = false;
+    } else if (name.startsWith("on")) {
+      this._globalEventChanged(name.substring(2));
+    }
+
+    super._attrModified.apply(this, arguments);
+  }
+
+  get offsetParent() {
+    return null;
+  }
+
+  get offsetTop() {
+    return 0;
+  }
+
+  get offsetLeft() {
+    return 0;
+  }
+
+  get offsetWidth() {
+    return 0;
+  }
+
+  get offsetHeight() {
+    return 0;
+  }
+}
+
+mixin(HTMLElementImpl.prototype, ElementCSSInlineStyleImpl.prototype);
+mixin(HTMLElementImpl.prototype, GlobalEventHandlersImpl.prototype);
+mixin(HTMLElementImpl.prototype, HTMLOrSVGElementImpl.prototype);
+
+module.exports = {
+  implementation: HTMLElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLEmbedElement-impl.js b/lib/jsdom/living/nodes/HTMLEmbedElement-impl.js
new file mode 100644
index 0000000..1e6ebb7
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLEmbedElement-impl.js
@@ -0,0 +1,17 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { reflectURLAttribute } = require("../../utils");
+
+class HTMLEmbedElementImpl extends HTMLElementImpl {
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLEmbedElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLFieldSetElement-impl.js b/lib/jsdom/living/nodes/HTMLFieldSetElement-impl.js
new file mode 100644
index 0000000..360a838
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLFieldSetElement-impl.js
@@ -0,0 +1,43 @@
+"use strict";
+const HTMLCollection = require("../generated/HTMLCollection");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { formOwner } = require("../helpers/form-controls");
+const { mixin } = require("../../utils");
+const { descendantsByLocalNames } = require("../helpers/traversal");
+
+const listedElements = new Set(["button", "fieldset", "input", "object", "output", "select", "textarea"]);
+
+class HTMLFieldSetElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._customValidityErrorMessage = "";
+  }
+
+  get elements() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => descendantsByLocalNames(this, listedElements)
+    });
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get type() {
+    return "fieldset";
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return true;
+  }
+}
+
+mixin(HTMLFieldSetElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLFieldSetElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLFontElement-impl.js b/lib/jsdom/living/nodes/HTMLFontElement-impl.js
new file mode 100644
index 0000000..688773a
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLFontElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLFontElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLFontElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLFormElement-impl.js b/lib/jsdom/living/nodes/HTMLFormElement-impl.js
new file mode 100644
index 0000000..1967ee4
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLFormElement-impl.js
@@ -0,0 +1,212 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { fireAnEvent } = require("../helpers/events");
+const { isListed, isSubmittable, isSubmitButton } = require("../helpers/form-controls");
+const HTMLCollection = require("../generated/HTMLCollection");
+const notImplemented = require("../../browser/not-implemented");
+const { reflectURLAttribute } = require("../../utils");
+
+const encTypes = new Set([
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+]);
+
+const methods = new Set([
+  "get",
+  "post",
+  "dialog"
+]);
+
+const constraintValidationPositiveResult = Symbol("positive");
+const constraintValidationNegativeResult = Symbol("negative");
+
+class HTMLFormElementImpl extends HTMLElementImpl {
+  _descendantAdded(parent, child) {
+    const form = this;
+    for (const el of domSymbolTree.treeIterator(child)) {
+      if (typeof el._changedFormOwner === "function") {
+        el._changedFormOwner(form);
+      }
+    }
+
+    super._descendantAdded.apply(this, arguments);
+  }
+
+  _descendantRemoved(parent, child) {
+    for (const el of domSymbolTree.treeIterator(child)) {
+      if (typeof el._changedFormOwner === "function") {
+        el._changedFormOwner(null);
+      }
+    }
+
+    super._descendantRemoved.apply(this, arguments);
+  }
+
+  // https://html.spec.whatwg.org/multipage/forms.html#dom-form-elements
+  get elements() {
+    // TODO: Return a HTMLFormControlsCollection
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => domSymbolTree.treeToArray(this, {
+        filter: node => isListed(node) && (node._localName !== "input" || node.type !== "image")
+      })
+    });
+  }
+
+  get length() {
+    return this.elements.length;
+  }
+
+  _doSubmit() {
+    if (!this.isConnected) {
+      return;
+    }
+
+    this.submit();
+  }
+
+  submit() {
+    if (!fireAnEvent("submit", this, undefined, { bubbles: true, cancelable: true })) {
+      return;
+    }
+
+    notImplemented("HTMLFormElement.prototype.submit", this._ownerDocument._defaultView);
+  }
+
+  requestSubmit(submitter = undefined) {
+    if (submitter !== undefined) {
+      if (!isSubmitButton(submitter)) {
+        throw new TypeError("The specified element is not a submit button");
+      }
+      if (submitter.form !== this) {
+        throw DOMException.create(this._globalObject, [
+          "The specified element is not owned by this form element",
+          "NotFoundError"
+        ]);
+      }
+    }
+
+    if (!fireAnEvent("submit", this, undefined, { bubbles: true, cancelable: true })) {
+      return;
+    }
+
+    notImplemented("HTMLFormElement.prototype.requestSubmit", this._ownerDocument._defaultView);
+  }
+
+  _doReset() {
+    if (!this.isConnected) {
+      return;
+    }
+
+    this.reset();
+  }
+
+  reset() {
+    if (!fireAnEvent("reset", this, undefined, { bubbles: true, cancelable: true })) {
+      return;
+    }
+
+    for (const el of this.elements) {
+      if (typeof el._formReset === "function") {
+        el._formReset();
+      }
+    }
+  }
+
+  get method() {
+    let method = this.getAttributeNS(null, "method");
+    if (method) {
+      method = method.toLowerCase();
+    }
+
+    if (methods.has(method)) {
+      return method;
+    }
+    return "get";
+  }
+
+  set method(V) {
+    this.setAttributeNS(null, "method", V);
+  }
+
+  get enctype() {
+    let type = this.getAttributeNS(null, "enctype");
+    if (type) {
+      type = type.toLowerCase();
+    }
+
+    if (encTypes.has(type)) {
+      return type;
+    }
+    return "application/x-www-form-urlencoded";
+  }
+
+  set enctype(V) {
+    this.setAttributeNS(null, "enctype", V);
+  }
+
+  get action() {
+    const attributeValue = this.getAttributeNS(null, "action");
+    if (attributeValue === null || attributeValue === "") {
+      return this._ownerDocument.URL;
+    }
+
+    return reflectURLAttribute(this, "action");
+  }
+
+  set action(V) {
+    this.setAttributeNS(null, "action", V);
+  }
+
+  // If the checkValidity() method is invoked, the user agent must statically validate the
+  // constraints of the form element, and return true if the constraint validation returned
+  // a positive result, and false if it returned a negative result.
+  checkValidity() {
+    return this._staticallyValidateConstraints().result === constraintValidationPositiveResult;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#interactively-validate-the-constraints
+  reportValidity() {
+    return this.checkValidity();
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#statically-validate-the-constraints
+  _staticallyValidateConstraints() {
+    const controls = [];
+    for (const el of domSymbolTree.treeIterator(this)) {
+      if (el.form === this && isSubmittable(el)) {
+        controls.push(el);
+      }
+    }
+
+    const invalidControls = [];
+
+    for (const control of controls) {
+      if (control._isCandidateForConstraintValidation() && !control._satisfiesConstraints()) {
+        invalidControls.push(control);
+      }
+    }
+
+    if (invalidControls.length === 0) {
+      return { result: constraintValidationPositiveResult };
+    }
+
+    const unhandledInvalidControls = [];
+    for (const invalidControl of invalidControls) {
+      const notCancelled = fireAnEvent("invalid", invalidControl, undefined, { cancelable: true });
+      if (notCancelled) {
+        unhandledInvalidControls.push(invalidControl);
+      }
+    }
+
+    return { result: constraintValidationNegativeResult, unhandledInvalidControls };
+  }
+}
+
+module.exports = {
+  implementation: HTMLFormElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLFrameElement-impl.js b/lib/jsdom/living/nodes/HTMLFrameElement-impl.js
new file mode 100644
index 0000000..f835d14
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLFrameElement-impl.js
@@ -0,0 +1,277 @@
+"use strict";
+
+const MIMEType = require("whatwg-mimetype");
+const whatwgEncoding = require("whatwg-encoding");
+const { parseURL, serializeURL } = require("whatwg-url");
+const sniffHTMLEncoding = require("html-encoding-sniffer");
+
+const window = require("../../browser/Window");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { evaluateJavaScriptURL } = require("../window/navigation");
+const { reflectURLAttribute } = require("../../utils");
+const { parseIntoDocument } = require("../../browser/parser");
+const { documentBaseURL } = require("../helpers/document-base-url");
+const { fireAnEvent } = require("../helpers/events");
+const { getAttributeValue } = require("../attributes");
+const idlUtils = require("../generated/utils");
+
+function fireLoadEvent(document, frame, attaching) {
+  if (attaching) {
+    fireAnEvent("load", frame);
+
+    return;
+  }
+
+  const dummyPromise = Promise.resolve();
+
+  function onLoad() {
+    fireAnEvent("load", frame);
+  }
+
+  document._queue.push(dummyPromise, onLoad);
+}
+
+function fetchFrame(serializedURL, frame, document, contentDoc) {
+  const resourceLoader = document._resourceLoader;
+
+  let request;
+
+  function onFrameLoaded(data) {
+    const sniffOptions = {
+      defaultEncoding: document._encoding
+    };
+
+    if (request.response) {
+      const contentType = MIMEType.parse(request.response.headers["content-type"]) || new MIMEType("text/plain");
+      sniffOptions.transportLayerEncodingLabel = contentType.parameters.get("charset");
+
+      if (contentType) {
+        if (contentType.isXML()) {
+          contentDoc._parsingMode = "xml";
+        }
+        contentDoc.contentType = contentType.essence;
+      }
+    }
+
+    const encoding = sniffHTMLEncoding(data, sniffOptions);
+    contentDoc._encoding = encoding;
+
+    const html = whatwgEncoding.decode(data, contentDoc._encoding);
+
+    try {
+      parseIntoDocument(html, contentDoc);
+    } catch (error) {
+      const { DOMException } = contentDoc._globalObject;
+
+      if (
+        error.constructor.name === "DOMException" &&
+        error.code === DOMException.SYNTAX_ERR &&
+        contentDoc._parsingMode === "xml"
+      ) {
+        // As defined (https://html.spec.whatwg.org/#read-xml) parsing error in XML document may be reported inline by
+        // mutating the document.
+        const element = contentDoc.createElementNS("http://www.mozilla.org/newlayout/xml/parsererror.xml", "parsererror");
+        element.textContent = error.message;
+
+        while (contentDoc.childNodes.length > 0) {
+          contentDoc.removeChild(contentDoc.lastChild);
+        }
+        contentDoc.appendChild(element);
+      } else {
+        throw error;
+      }
+    }
+
+    contentDoc.close();
+
+    return new Promise((resolve, reject) => {
+      contentDoc.addEventListener("load", resolve);
+      contentDoc.addEventListener("error", reject);
+    });
+  }
+
+  request = resourceLoader.fetch(serializedURL, {
+    element: frame,
+    onLoad: onFrameLoaded
+  });
+}
+
+function canDispatchEvents(frame, attaching) {
+  if (!attaching) {
+    return false;
+  }
+
+  return Object.keys(frame._eventListeners).length === 0;
+}
+
+function loadFrame(frame, attaching) {
+  if (frame._contentDocument) {
+    if (frame._contentDocument._defaultView) {
+      // close calls delete on its document.
+      frame._contentDocument._defaultView.close();
+    } else {
+      delete frame._contentDocument;
+    }
+  }
+
+  const parentDoc = frame._ownerDocument;
+
+  // https://html.spec.whatwg.org/#process-the-iframe-attributes
+  let url;
+  const srcAttribute = getAttributeValue(frame, "src");
+  if (srcAttribute === "") {
+    url = parseURL("about:blank");
+  } else {
+    url = parseURL(srcAttribute, { baseURL: documentBaseURL(parentDoc) || undefined }) || parseURL("about:blank");
+  }
+  const serializedURL = serializeURL(url);
+
+  const wnd = window.createWindow({
+    parsingMode: "html",
+    url: url.scheme === "javascript" || serializedURL === "about:blank" ? parentDoc.URL : serializedURL,
+    resourceLoader: parentDoc._defaultView._resourceLoader,
+    referrer: parentDoc.URL,
+    cookieJar: parentDoc._cookieJar,
+    pool: parentDoc._pool,
+    encoding: parentDoc._encoding,
+    runScripts: parentDoc._defaultView._runScripts,
+    commonForOrigin: parentDoc._defaultView._commonForOrigin,
+    pretendToBeVisual: parentDoc._defaultView._pretendToBeVisual
+  });
+
+  const contentDoc = frame._contentDocument = idlUtils.implForWrapper(wnd._document);
+  const parent = parentDoc._defaultView;
+  const contentWindow = contentDoc._defaultView;
+  contentWindow._parent = parent;
+  contentWindow._top = parent.top;
+  contentWindow._frameElement = frame;
+  contentWindow._virtualConsole = parent._virtualConsole;
+
+  if (parentDoc._origin === contentDoc._origin) {
+    contentWindow._currentOriginData.windowsInSameOrigin.push(contentWindow);
+  }
+
+  const noQueue = canDispatchEvents(frame, attaching);
+
+  // Handle about:blank with a simulated load of an empty document.
+  if (serializedURL === "about:blank") {
+    // Cannot be done inside the enqueued callback; the documentElement etc. need to be immediately available.
+    parseIntoDocument("<html><head></head><body></body></html>", contentDoc);
+    contentDoc.close(noQueue);
+
+    if (noQueue) {
+      fireLoadEvent(parentDoc, frame, noQueue);
+    } else {
+      contentDoc.addEventListener("load", () => {
+        fireLoadEvent(parentDoc, frame);
+      });
+    }
+  } else if (url.scheme === "javascript") {
+    // Cannot be done inside the enqueued callback; the documentElement etc. need to be immediately available.
+    parseIntoDocument("<html><head></head><body></body></html>", contentDoc);
+    contentDoc.close(noQueue);
+    const result = evaluateJavaScriptURL(contentWindow, url);
+    if (typeof result === "string") {
+      contentDoc.body.textContent = result;
+    }
+    if (noQueue) {
+      fireLoadEvent(parentDoc, frame, noQueue);
+    } else {
+      contentDoc.addEventListener("load", () => {
+        fireLoadEvent(parentDoc, frame);
+      });
+    }
+  } else {
+    fetchFrame(serializedURL, frame, parentDoc, contentDoc);
+  }
+}
+
+function refreshAccessors(document) {
+  const { _defaultView } = document;
+
+  if (!_defaultView) {
+    return;
+  }
+
+  const frames = document.querySelectorAll("iframe,frame");
+
+  // delete accessors for all frames
+  for (let i = 0; i < _defaultView._length; ++i) {
+    delete _defaultView[i];
+  }
+
+  _defaultView._length = frames.length;
+  Array.prototype.forEach.call(frames, (frame, i) => {
+    Object.defineProperty(_defaultView, i, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return frame.contentWindow;
+      }
+    });
+  });
+}
+
+class HTMLFrameElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._contentDocument = null;
+  }
+  _attrModified(name, value, oldVal) {
+    super._attrModified(name, value, oldVal);
+    if (name === "src") {
+      // iframe should never load in a document without a Window
+      // (e.g. implementation.createHTMLDocument)
+      if (this._attached && this._ownerDocument._defaultView) {
+        loadFrame(this);
+      }
+    }
+  }
+
+  _detach() {
+    super._detach();
+
+    if (this.contentWindow) {
+      this.contentWindow.close();
+    }
+
+    refreshAccessors(this._ownerDocument);
+  }
+
+  _attach() {
+    super._attach();
+
+    if (this._ownerDocument._defaultView) {
+      loadFrame(this, true);
+    }
+    refreshAccessors(this._ownerDocument);
+  }
+
+  get contentDocument() {
+    return this._contentDocument;
+  }
+
+  get contentWindow() {
+    return this.contentDocument ? this.contentDocument._defaultView : null;
+  }
+
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+
+  get longDesc() {
+    return reflectURLAttribute(this, "longdesc");
+  }
+
+  set longDesc(value) {
+    this.setAttributeNS(null, "longdesc", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLFrameElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLFrameSetElement-impl.js b/lib/jsdom/living/nodes/HTMLFrameSetElement-impl.js
new file mode 100644
index 0000000..89eee2d
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLFrameSetElement-impl.js
@@ -0,0 +1,17 @@
+"use strict";
+const { mixin } = require("../../utils");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const WindowEventHandlersImpl = require("./WindowEventHandlers-impl").implementation;
+
+class HTMLFrameSetElementImpl extends HTMLElementImpl {
+  constructor(...args) {
+    super(...args);
+    this._proxyWindowEventsToWindow();
+  }
+}
+
+mixin(HTMLFrameSetElementImpl.prototype, WindowEventHandlersImpl.prototype);
+
+module.exports = {
+  implementation: HTMLFrameSetElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLHRElement-impl.js b/lib/jsdom/living/nodes/HTMLHRElement-impl.js
new file mode 100644
index 0000000..8c5d337
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLHRElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLHRElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLHRElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLHeadElement-impl.js b/lib/jsdom/living/nodes/HTMLHeadElement-impl.js
new file mode 100644
index 0000000..6803377
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLHeadElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLHeadElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLHeadElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLHeadingElement-impl.js b/lib/jsdom/living/nodes/HTMLHeadingElement-impl.js
new file mode 100644
index 0000000..4fb4250
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLHeadingElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLHeadingElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLHeadingElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLHtmlElement-impl.js b/lib/jsdom/living/nodes/HTMLHtmlElement-impl.js
new file mode 100644
index 0000000..bda1780
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLHtmlElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLHtmlElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLHtmlElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLHyperlinkElementUtils-impl.js b/lib/jsdom/living/nodes/HTMLHyperlinkElementUtils-impl.js
new file mode 100644
index 0000000..004c60c
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLHyperlinkElementUtils-impl.js
@@ -0,0 +1,371 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const { parseURLToResultingURLRecord } = require("../helpers/document-base-url");
+const { asciiCaseInsensitiveMatch } = require("../helpers/strings");
+const { navigate } = require("../window/navigation");
+
+exports.implementation = class HTMLHyperlinkElementUtilsImpl {
+  _htmlHyperlinkElementUtilsSetup() {
+    this.url = null;
+  }
+
+  // https://html.spec.whatwg.org/multipage/links.html#cannot-navigate
+  _cannotNavigate() {
+    // TODO: Correctly check if the document is fully active
+    return this._localName !== "a" && !this.isConnected;
+  }
+
+  // https://html.spec.whatwg.org/multipage/semantics.html#get-an-element's-target
+  _getAnElementsTarget() {
+    if (this.hasAttributeNS(null, "target")) {
+      return this.getAttributeNS(null, "target");
+    }
+
+    const baseEl = this._ownerDocument.querySelector("base[target]");
+
+    if (baseEl) {
+      return baseEl.getAttributeNS(null, "target");
+    }
+
+    return "";
+  }
+
+  // https://html.spec.whatwg.org/multipage/browsers.html#the-rules-for-choosing-a-browsing-context-given-a-browsing-context-name
+  _chooseABrowsingContext(name, current) {
+    let chosen = null;
+
+    if (name === "" || asciiCaseInsensitiveMatch(name, "_self")) {
+      chosen = current;
+    } else if (asciiCaseInsensitiveMatch(name, "_parent")) {
+      chosen = current.parent;
+    } else if (asciiCaseInsensitiveMatch(name, "_top")) {
+      chosen = current.top;
+    } else if (!asciiCaseInsensitiveMatch(name, "_blank")) {
+      // https://github.com/whatwg/html/issues/1440
+    }
+
+    // TODO: Create new browsing context, handle noopener
+
+    return chosen;
+  }
+
+  // https://html.spec.whatwg.org/multipage/links.html#following-hyperlinks-2
+  _followAHyperlink() {
+    if (this._cannotNavigate()) {
+      return;
+    }
+
+    const source = this._ownerDocument._defaultView;
+    let targetAttributeValue = "";
+
+    if (this._localName === "a" || this._localName === "area") {
+      targetAttributeValue = this._getAnElementsTarget();
+    }
+
+    const noopener = this.relList.contains("noreferrer") || this.relList.contains("noopener");
+
+    const target = this._chooseABrowsingContext(targetAttributeValue, source, noopener);
+
+    if (target === null) {
+      return;
+    }
+
+    const url = parseURLToResultingURLRecord(this.href, this._ownerDocument);
+
+    if (url === null) {
+      return;
+    }
+
+    // TODO: Handle hyperlink suffix and referrerpolicy
+    setTimeout(() => {
+      navigate(target, url, {});
+    }, 0);
+  }
+
+  toString() {
+    return this.href;
+  }
+
+  get href() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null) {
+      const href = this.getAttributeNS(null, "href");
+      return href === null ? "" : href;
+    }
+
+    return whatwgURL.serializeURL(url);
+  }
+
+  set href(v) {
+    this.setAttributeNS(null, "href", v);
+  }
+
+  get origin() {
+    reinitializeURL(this);
+
+    if (this.url === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeURLOrigin(this.url);
+  }
+
+  get protocol() {
+    reinitializeURL(this);
+
+    if (this.url === null) {
+      return ":";
+    }
+
+    return this.url.scheme + ":";
+  }
+
+  set protocol(v) {
+    reinitializeURL(this);
+
+    if (this.url === null) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v + ":", { url: this.url, stateOverride: "scheme start" });
+    updateHref(this);
+  }
+
+  get username() {
+    reinitializeURL(this);
+
+    if (this.url === null) {
+      return "";
+    }
+
+    return this.url.username;
+  }
+
+  set username(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file") {
+      return;
+    }
+
+    whatwgURL.setTheUsername(url, v);
+    updateHref(this);
+  }
+
+  get password() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null) {
+      return "";
+    }
+
+    return url.password;
+  }
+
+  set password(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file") {
+      return;
+    }
+
+    whatwgURL.setThePassword(url, v);
+    updateHref(this);
+  }
+
+  get host() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.host === null) {
+      return "";
+    }
+
+    if (url.port === null) {
+      return whatwgURL.serializeHost(url.host);
+    }
+
+    return whatwgURL.serializeHost(url.host) + ":" + whatwgURL.serializeInteger(url.port);
+  }
+
+  set host(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.cannotBeABaseURL) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url, stateOverride: "host" });
+    updateHref(this);
+  }
+
+  get hostname() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.host === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeHost(url.host);
+  }
+
+  set hostname(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.cannotBeABaseURL) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url, stateOverride: "hostname" });
+    updateHref(this);
+  }
+
+  get port() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.port === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeInteger(url.port);
+  }
+
+  set port(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file") {
+      return;
+    }
+
+    if (v === "") {
+      url.port = null;
+    } else {
+      whatwgURL.basicURLParse(v, { url, stateOverride: "port" });
+    }
+    updateHref(this);
+  }
+
+  get pathname() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null) {
+      return "";
+    }
+
+    if (url.cannotBeABaseURL) {
+      return url.path[0];
+    }
+
+    return "/" + url.path.join("/");
+  }
+
+  set pathname(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.cannotBeABaseURL) {
+      return;
+    }
+
+    url.path = [];
+    whatwgURL.basicURLParse(v, { url, stateOverride: "path start" });
+    updateHref(this);
+  }
+
+  get search() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.query === null || url.query === "") {
+      return "";
+    }
+
+    return "?" + url.query;
+  }
+
+  set search(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null) {
+      return;
+    }
+
+    if (v === "") {
+      url.query = null;
+    } else {
+      const input = v[0] === "?" ? v.substring(1) : v;
+      url.query = "";
+      whatwgURL.basicURLParse(input, {
+        url,
+        stateOverride: "query",
+        encodingOverride: this._ownerDocument.charset
+      });
+    }
+    updateHref(this);
+  }
+
+  get hash() {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null || url.fragment === null || url.fragment === "") {
+      return "";
+    }
+
+    return "#" + url.fragment;
+  }
+
+  set hash(v) {
+    reinitializeURL(this);
+    const { url } = this;
+
+    if (url === null) {
+      return;
+    }
+
+    if (v === "") {
+      url.fragment = null;
+    } else {
+      const input = v[0] === "#" ? v.substring(1) : v;
+      url.fragment = "";
+      whatwgURL.basicURLParse(input, { url, stateOverride: "fragment" });
+    }
+    updateHref(this);
+  }
+};
+
+function reinitializeURL(hheu) {
+  if (hheu.url !== null && hheu.url.scheme === "blob" && hheu.url.cannotBeABaseURL) {
+    return;
+  }
+
+  setTheURL(hheu);
+}
+
+function setTheURL(hheu) {
+  const href = hheu.getAttributeNS(null, "href");
+  if (href === null) {
+    hheu.url = null;
+    return;
+  }
+
+  const parsed = parseURLToResultingURLRecord(href, hheu._ownerDocument);
+
+  hheu.url = parsed === null ? null : parsed;
+}
+
+function updateHref(hheu) {
+  hheu.setAttributeNS(null, "href", whatwgURL.serializeURL(hheu.url));
+}
diff --git a/lib/jsdom/living/nodes/HTMLIFrameElement-impl.js b/lib/jsdom/living/nodes/HTMLIFrameElement-impl.js
new file mode 100644
index 0000000..643e989
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLIFrameElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLFrameElementImpl = require("./HTMLFrameElement-impl").implementation;
+
+class HTMLIFrameElementImpl extends HTMLFrameElementImpl { }
+
+module.exports = {
+  implementation: HTMLIFrameElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLImageElement-impl.js b/lib/jsdom/living/nodes/HTMLImageElement-impl.js
new file mode 100644
index 0000000..aa42455
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLImageElement-impl.js
@@ -0,0 +1,142 @@
+"use strict";
+const conversions = require("webidl-conversions");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { Canvas, reflectURLAttribute } = require("../../utils");
+
+class HTMLImageElementImpl extends HTMLElementImpl {
+  _attrModified(name, value, oldVal) {
+    // TODO: handle crossorigin
+    if (name === "src" || ((name === "srcset" || name === "width" || name === "sizes") && value !== oldVal)) {
+      this._updateTheImageData();
+    }
+
+    super._attrModified(name, value, oldVal);
+  }
+
+  get _accept() {
+    return "image/png,image/*;q=0.8,*/*;q=0.5";
+  }
+
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+
+  get srcset() {
+    return conversions.USVString(this.getAttributeNS(null, "srcset"));
+  }
+
+  set srcset(value) {
+    this.setAttributeNS(null, "srcset", value);
+  }
+
+  get height() {
+    // Just like on browsers, if no width / height is defined, we fall back on the
+    // dimensions of the internal image data.
+    return this.hasAttributeNS(null, "height") ?
+           conversions["unsigned long"](this.getAttributeNS(null, "height")) :
+           this.naturalHeight;
+  }
+
+  set height(V) {
+    this.setAttributeNS(null, "height", String(V));
+  }
+
+  get width() {
+    return this.hasAttributeNS(null, "width") ?
+           conversions["unsigned long"](this.getAttributeNS(null, "width")) :
+           this.naturalWidth;
+  }
+
+  set width(V) {
+    this.setAttributeNS(null, "width", String(V));
+  }
+
+  get naturalHeight() {
+    return this._image ? this._image.naturalHeight : 0;
+  }
+
+  get naturalWidth() {
+    return this._image ? this._image.naturalWidth : 0;
+  }
+
+  get complete() {
+    return Boolean(this._image && this._image.complete);
+  }
+
+  get currentSrc() {
+    return this._currentSrc || "";
+  }
+
+  get lowsrc() {
+    return reflectURLAttribute(this, "lowsrc");
+  }
+
+  set lowsrc(value) {
+    this.setAttributeNS(null, "lowsrc", value);
+  }
+
+  get longDesc() {
+    return reflectURLAttribute(this, "longdesc");
+  }
+
+  set longDesc(value) {
+    this.setAttributeNS(null, "longdesc", value);
+  }
+
+  _updateTheImageData() {
+    const document = this._ownerDocument;
+
+    if (!document._defaultView) {
+      return;
+    }
+
+    if (!Canvas) {
+      return;
+    }
+
+    let error;
+    if (!this._image) {
+      this._image = new Canvas.Image();
+      // Install an error handler that just remembers the error. It is then
+      // thrown in the callback of resourceLoader.fetch() below.
+      this._image.onerror = function (err) {
+        error = err;
+      };
+    }
+    this._currentSrc = null;
+    const srcAttributeValue = this.getAttributeNS(null, "src");
+    if (srcAttributeValue !== null && srcAttributeValue !== "") {
+      const resourceLoader = document._resourceLoader;
+      let request;
+
+      const onLoadImage = data => {
+        const { response } = request;
+
+        if (response && response.statusCode !== undefined && response.statusCode !== 200) {
+          throw new Error("Status code: " + response.statusCode);
+        }
+        error = null;
+        this._image.src = data;
+        if (error) {
+          throw new Error(error);
+        }
+        this._currentSrc = srcAttributeValue;
+      };
+
+      request = resourceLoader.fetch(this.src, {
+        element: this,
+        onLoad: onLoadImage
+      });
+    } else {
+      this._image.src = "";
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLImageElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLInputElement-impl.js b/lib/jsdom/living/nodes/HTMLInputElement-impl.js
new file mode 100644
index 0000000..3ad00e8
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLInputElement-impl.js
@@ -0,0 +1,1143 @@
+"use strict";
+const conversions = require("webidl-conversions");
+const DOMException = require("domexception/webidl2js-wrapper");
+const FileList = require("../generated/FileList");
+const Decimal = require("decimal.js");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const idlUtils = require("../generated/utils");
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const ValidityState = require("../generated/ValidityState");
+const { mixin } = require("../../utils");
+const { domSymbolTree, cloningSteps } = require("../helpers/internal-constants");
+const { getLabelsForLabelable, formOwner } = require("../helpers/form-controls");
+const { fireAnEvent } = require("../helpers/events");
+const {
+  isDisabled,
+  isValidEmailAddress,
+  isValidAbsoluteURL,
+  sanitizeValueByType
+} = require("../helpers/form-controls");
+const {
+  asciiCaseInsensitiveMatch,
+  asciiLowercase,
+  parseFloatingPointNumber,
+  splitOnCommas
+} = require("../helpers/strings");
+const { isDate } = require("../helpers/dates-and-times");
+const {
+  convertStringToNumberByType,
+  convertStringToDateByType,
+  serializeDateByType,
+  convertNumberToStringByType
+} = require("../helpers/number-and-date-inputs");
+
+const filesSymbol = Symbol("files");
+
+// https://html.spec.whatwg.org/multipage/input.html#attr-input-type
+const inputAllowedTypes = new Set([
+  "hidden", "text", "search", "tel", "url", "email", "password", "date",
+  "month", "week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio",
+  "file", "submit", "image", "reset", "button"
+]);
+
+// https://html.spec.whatwg.org/multipage/input.html#concept-input-apply
+
+const variableLengthSelectionAllowedTypes = new Set(["text", "search", "url", "tel", "password"]);
+const numericTypes = new Set(["date", "month", "week", "time", "datetime-local", "number", "range"]);
+
+const applicableTypesForIDLMember = {
+  valueAsDate: new Set(["date", "month", "week", "time"]),
+  valueAsNumber: numericTypes,
+
+  select: new Set([
+    "text", "search", "url", "tel", "email", "password", "date", "month", "week",
+    "time", "datetime-local", "number", "color", "file"
+  ]),
+  selectionStart: variableLengthSelectionAllowedTypes,
+  selectionEnd: variableLengthSelectionAllowedTypes,
+  selectionDirection: variableLengthSelectionAllowedTypes,
+  setRangeText: variableLengthSelectionAllowedTypes,
+  setSelectionRange: variableLengthSelectionAllowedTypes,
+  stepDown: numericTypes,
+  stepUp: numericTypes
+};
+
+const lengthPatternSizeTypes = new Set(["text", "search", "url", "tel", "email", "password"]);
+const readonlyTypes =
+  new Set([...lengthPatternSizeTypes, "date", "month", "week", "time", "datetime-local", "number"]);
+
+const applicableTypesForContentAttribute = {
+  list: new Set(["text", "search", "url", "tel", "email", ...numericTypes, "color"]),
+  max: numericTypes,
+  maxlength: lengthPatternSizeTypes,
+  min: numericTypes,
+  minlength: lengthPatternSizeTypes,
+  multiple: new Set(["email", "file"]),
+  pattern: lengthPatternSizeTypes,
+  readonly: readonlyTypes,
+  required: new Set([...readonlyTypes, "checkbox", "radio", "file"]),
+  step: numericTypes
+};
+
+const valueAttributeDefaultMode = new Set(["hidden", "submit", "image", "reset", "button"]);
+const valueAttributeDefaultOnMode = new Set(["checkbox", "radio"]);
+
+function valueAttributeMode(type) {
+  if (valueAttributeDefaultMode.has(type)) {
+    return "default";
+  }
+  if (valueAttributeDefaultOnMode.has(type)) {
+    return "default/on";
+  }
+  if (type === "file") {
+    return "filename";
+  }
+  return "value";
+}
+
+function getTypeFromAttribute(typeAttribute) {
+  if (typeof typeAttribute !== "string") {
+    return "text";
+  }
+  const type = asciiLowercase(typeAttribute);
+  return inputAllowedTypes.has(type) ? type : "text";
+}
+
+class HTMLInputElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._selectionStart = this._selectionEnd = 0;
+    this._selectionDirection = "none";
+    this._value = "";
+    this._dirtyValue = false;
+    this._checkedness = false;
+    this._dirtyCheckedness = false;
+
+    this._preCheckedRadioState = null;
+
+    this.indeterminate = false;
+
+    this._customValidityErrorMessage = "";
+
+    this._labels = null;
+
+    this._hasActivationBehavior = true;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-value-string-number
+  get _convertStringToNumber() {
+    return convertStringToNumberByType[this.type];
+  }
+
+  get _convertNumberToString() {
+    return convertNumberToStringByType[this.type];
+  }
+
+  get _convertDateToString() {
+    return serializeDateByType[this.type];
+  }
+
+  get _convertStringToDate() {
+    return convertStringToDateByType[this.type];
+  }
+
+  _isStepAligned(v) {
+    return new Decimal(v).minus(this._stepBase)
+      .modulo(this._allowedValueStep)
+      .isZero();
+  }
+
+  _stepAlign(v, roundUp) {
+    if (this._isStepAligned(v)) {
+      return v;
+    }
+
+    const relativeDistance = v - this._stepBase;
+    const stepIntervalCount = Math.trunc(relativeDistance / this._allowedValueStep);
+    let candidate = stepIntervalCount * this._allowedValueStep;
+
+    if (roundUp) {
+      if (v > candidate) {
+        candidate += this._allowedValueStep;
+      }
+    } else if (v < candidate) {
+      candidate -= this._allowedValueStep;
+    }
+    return candidate + this._stepBase;
+  }
+
+  // For <input>, https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-fe-value
+  // is a simple value that is gotten and set, not computed.
+  _getValue() {
+    return this._value;
+  }
+
+  _legacyPreActivationBehavior() {
+    // The spec says we should check this._mutable here, but browsers don't seem to implement this behavior. See
+    // https://github.com/whatwg/html/issues/3239.
+    if (this.type === "checkbox") {
+      this.checked = !this.checked;
+    } else if (this.type === "radio") {
+      this._preCheckedRadioState = this.checked;
+      this.checked = true;
+    }
+  }
+
+  _legacyCanceledActivationBehavior() {
+    // The spec says we should check this._mutable here, but browsers don't seem to implement this behavior. See
+    // https://github.com/whatwg/html/issues/3239.
+    if (this.type === "checkbox") {
+      this.checked = !this.checked;
+    } else if (this.type === "radio") {
+      if (this._preCheckedRadioState !== null) {
+        this.checked = this._preCheckedRadioState;
+        this._preCheckedRadioState = null;
+      }
+    }
+  }
+
+  _activationBehavior() {
+    if (!this._mutable) {
+      return;
+    }
+
+    const { form } = this;
+
+    if (this.type === "checkbox" || (this.type === "radio" && !this._preCheckedRadioState)) {
+      fireAnEvent("input", this, undefined, { bubbles: true });
+      fireAnEvent("change", this, undefined, { bubbles: true });
+    } else if (form && this.type === "submit") {
+      form._doSubmit();
+    } else if (form && this.type === "reset") {
+      form._doReset();
+    }
+  }
+
+  _attrModified(name, value, oldVal) {
+    const wrapper = idlUtils.wrapperForImpl(this);
+    if (!this._dirtyValue && name === "value") {
+      this._value = sanitizeValueByType(this, wrapper.defaultValue);
+    }
+    if (!this._dirtyCheckedness && name === "checked") {
+      this._checkedness = wrapper.defaultChecked;
+      if (this._checkedness) {
+        this._removeOtherRadioCheckedness();
+      }
+    }
+
+    if (name === "name" || name === "type") {
+      if (this._checkedness) {
+        this._removeOtherRadioCheckedness();
+      }
+    }
+
+    if (name === "type") {
+      const prevType = getTypeFromAttribute(oldVal);
+      const curType = getTypeFromAttribute(value);
+      // When an input element's type attribute changes state…
+      if (prevType !== curType) {
+        const prevValueMode = valueAttributeMode(prevType);
+        const curValueMode = valueAttributeMode(curType);
+        if (prevValueMode === "value" && this._value !== "" &&
+            (curValueMode === "default" || curValueMode === "default/on")) {
+          this.setAttributeNS(null, "value", this._value);
+        } else if (prevValueMode !== "value" && curValueMode === "value") {
+          this._value = this.getAttributeNS(null, "value") || "";
+          this._dirtyValue = false;
+        } else if (prevValueMode !== "filename" && curValueMode === "filename") {
+          this._value = "";
+        }
+
+        this._signalATypeChange();
+
+        this._value = sanitizeValueByType(this, this._value);
+
+        const previouslySelectable = this._idlMemberApplies("setRangeText", prevType);
+        const nowSelectable = this._idlMemberApplies("setRangeText", curType);
+        if (!previouslySelectable && nowSelectable) {
+          this._selectionStart = 0;
+          this._selectionEnd = 0;
+          this._selectionDirection = "none";
+        }
+      }
+    }
+
+    super._attrModified.apply(this, arguments);
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#signal-a-type-change
+  _signalATypeChange() {
+    if (this._checkedness) {
+      this._removeOtherRadioCheckedness();
+    }
+  }
+
+  _formReset() {
+    const wrapper = idlUtils.wrapperForImpl(this);
+    this._value = sanitizeValueByType(this, wrapper.defaultValue);
+    this._dirtyValue = false;
+    this._checkedness = wrapper.defaultChecked;
+    this._dirtyCheckedness = false;
+    if (this._checkedness) {
+      this._removeOtherRadioCheckedness();
+    }
+  }
+
+  _changedFormOwner() {
+    if (this._checkedness) {
+      this._removeOtherRadioCheckedness();
+    }
+  }
+
+  get _otherRadioGroupElements() {
+    const wrapper = idlUtils.wrapperForImpl(this);
+    const root = this._radioButtonGroupRoot;
+    if (!root) {
+      return [];
+    }
+
+    const result = [];
+
+    const descendants = domSymbolTree.treeIterator(root);
+    for (const candidate of descendants) {
+      if (candidate._radioButtonGroupRoot !== root) {
+        continue;
+      }
+
+      const candidateWrapper = idlUtils.wrapperForImpl(candidate);
+      if (!candidateWrapper.name || candidateWrapper.name !== wrapper.name) {
+        continue;
+      }
+
+      if (candidate !== this) {
+        result.push(candidate);
+      }
+    }
+    return result;
+  }
+
+  _removeOtherRadioCheckedness() {
+    for (const radioGroupElement of this._otherRadioGroupElements) {
+      radioGroupElement._checkedness = false;
+    }
+  }
+
+  get _radioButtonGroupRoot() {
+    const wrapper = idlUtils.wrapperForImpl(this);
+    if (this.type !== "radio" || !wrapper.name) {
+      return null;
+    }
+
+    let e = domSymbolTree.parent(this);
+    while (e) {
+      // root node of this home sub tree
+      // or the form element we belong to
+      if (!domSymbolTree.parent(e) || e.nodeName.toUpperCase() === "FORM") {
+        return e;
+      }
+      e = domSymbolTree.parent(e);
+    }
+    return null;
+  }
+
+  _isRadioGroupChecked() {
+    if (this.checked) {
+      return true;
+    }
+    return this._otherRadioGroupElements.some(radioGroupElement => radioGroupElement.checked);
+  }
+
+  get _mutable() {
+    return !isDisabled(this) && !this._hasAttributeAndApplies("readonly");
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get checked() {
+    return this._checkedness;
+  }
+
+  set checked(checked) {
+    this._checkedness = Boolean(checked);
+    this._dirtyCheckedness = true;
+    if (this._checkedness) {
+      this._removeOtherRadioCheckedness();
+    }
+  }
+
+  get value() {
+    switch (valueAttributeMode(this.type)) {
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-value
+      case "value":
+        return this._getValue();
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-default
+      case "default": {
+        const attr = this.getAttributeNS(null, "value");
+        return attr !== null ? attr : "";
+      }
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-default-on
+      case "default/on": {
+        const attr = this.getAttributeNS(null, "value");
+        return attr !== null ? attr : "on";
+      }
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-filename
+      case "filename":
+        return this.files.length ? "C:\\fakepath\\" + this.files[0].name : "";
+      default:
+        throw new Error("jsdom internal error: unknown value attribute mode");
+    }
+  }
+
+  set value(val) {
+    switch (valueAttributeMode(this.type)) {
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-value
+      case "value": {
+        const oldValue = this._value;
+        this._value = sanitizeValueByType(this, val);
+        this._dirtyValue = true;
+
+        if (oldValue !== this._value) {
+          this._selectionStart = this._selectionEnd = this._getValueLength();
+          this._selectionDirection = "none";
+        }
+        break;
+      }
+
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-default
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-default-on
+      case "default":
+      case "default/on":
+        this.setAttributeNS(null, "value", val);
+        break;
+
+      // https://html.spec.whatwg.org/multipage/input.html#dom-input-value-filename
+      case "filename":
+        if (val === "") {
+          this.files.length = 0;
+        } else {
+          throw DOMException.create(this._globalObject, [
+            "This input element accepts a filename, which may only be programmatically set to the empty string.",
+            "InvalidStateError"
+          ]);
+        }
+        break;
+
+      default:
+        throw new Error("jsdom internal error: unknown value attribute mode");
+    }
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#dom-input-valueasdate
+  get valueAsDate() {
+    if (!this._idlMemberApplies("valueAsDate")) {
+      return null;
+    }
+
+    const window = this._ownerDocument._defaultView;
+    const convertedValue = this._convertStringToDate(this._value);
+
+    if (convertedValue instanceof Date) {
+      return new window.Date(convertedValue.getTime());
+    }
+
+    return null;
+  }
+
+  set valueAsDate(v) {
+    if (!this._idlMemberApplies("valueAsDate")) {
+      throw DOMException.create(this._globalObject, [
+        "Failed to set the 'valueAsDate' property on 'HTMLInputElement': This input element does not support Date " +
+        "values.",
+        "InvalidStateError"
+      ]);
+    }
+
+    if (v !== null && !isDate(v)) {
+      throw new TypeError("Failed to set the 'valueAsDate' property on 'HTMLInputElement': The provided value is " +
+        "not a Date.");
+    }
+
+    if (v === null || isNaN(v)) {
+      this._value = "";
+    }
+
+    this._value = this._convertDateToString(v);
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#dom-input-valueasnumber
+  get valueAsNumber() {
+    if (!this._idlMemberApplies("valueAsNumber")) {
+      return NaN;
+    }
+
+    const parsedValue = this._convertStringToNumber(this._value);
+    return parsedValue !== null ? parsedValue : NaN;
+  }
+
+  set valueAsNumber(v) {
+    if (!isFinite(v)) {
+      throw new TypeError("Failed to set infinite value as Number");
+    }
+
+    if (!this._idlMemberApplies("valueAsNumber")) {
+      throw DOMException.create(this._globalObject, [
+        "Failed to set the 'valueAsNumber' property on 'HTMLInputElement': This input element does not support " +
+        "Number values.",
+        "InvalidStateError"
+      ]);
+    }
+
+    this._value = this._convertNumberToString(v);
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#dom-input-stepup
+  _stepUpdate(n, isUp) {
+    const methodName = isUp ? "stepUp" : "stepDown";
+    if (!this._idlMemberApplies(methodName)) {
+      throw DOMException.create(this._globalObject, [
+        `Failed to invoke '${methodName}' method on 'HTMLInputElement': ` +
+        "This input element does not support Number values.",
+        "InvalidStateError"
+      ]);
+    }
+
+    const allowedValueStep = this._allowedValueStep;
+    if (allowedValueStep === null) {
+      throw DOMException.create(this._globalObject, [
+        `Failed to invoke '${methodName}' method on 'HTMLInputElement': ` +
+        "This input element does not support value step.",
+        "InvalidStateError"
+      ]);
+    }
+
+    const min = this._minimum;
+    const max = this._maximum;
+
+    if (min !== null && max !== null) {
+      if (min > max) {
+        return;
+      }
+
+      const candidateStepValue = this._stepAlign(min + allowedValueStep, false);
+      if (candidateStepValue < min || candidateStepValue > max) {
+        return;
+      }
+    }
+
+    let value = 0;
+    try {
+      value = this.valueAsNumber;
+      if (isNaN(value)) { // Empty value is parsed as NaN.
+        value = 0;
+      }
+    } catch (error) {
+      // Step 5. Default value is 0.
+    }
+
+    const valueBeforeStepping = value;
+
+    if (!this._isStepAligned(value)) {
+      value = this._stepAlign(value, /* roundUp = */ isUp);
+    }
+
+    let delta = n * allowedValueStep;
+    if (!isUp) {
+      delta *= -1;
+    }
+    value += delta;
+
+    if (min !== null && value < min) {
+      value = this._stepAlign(min, /* roundUp = */ true);
+    }
+
+    if (max !== null && value > max) {
+      value = this._stepAlign(max, /* roundUp = */ false);
+    }
+
+    if (isUp ? value < valueBeforeStepping : value > valueBeforeStepping) {
+      return;
+    }
+
+    this._value = this._convertNumberToString(value);
+  }
+
+  stepDown(n = 1) {
+    return this._stepUpdate(n, false);
+  }
+
+  stepUp(n = 1) {
+    return this._stepUpdate(n, true);
+  }
+
+  get files() {
+    if (this.type === "file") {
+      this[filesSymbol] = this[filesSymbol] || FileList.createImpl(this._globalObject);
+    } else {
+      this[filesSymbol] = null;
+    }
+    return this[filesSymbol];
+  }
+
+  set files(value) {
+    if (this.type === "file" && value !== null) {
+      this[filesSymbol] = value;
+    }
+  }
+
+  get type() {
+    const typeAttribute = this.getAttributeNS(null, "type");
+    return getTypeFromAttribute(typeAttribute);
+  }
+
+  set type(type) {
+    this.setAttributeNS(null, "type", type);
+  }
+
+  _dispatchSelectEvent() {
+    fireAnEvent("select", this, undefined, { bubbles: true, cancelable: true });
+  }
+
+  _getValueLength() {
+    return typeof this.value === "string" ? this.value.length : 0;
+  }
+
+  select() {
+    if (!this._idlMemberApplies("select")) {
+      return;
+    }
+
+    this._selectionStart = 0;
+    this._selectionEnd = this._getValueLength();
+    this._selectionDirection = "none";
+    this._dispatchSelectEvent();
+  }
+
+  get selectionStart() {
+    if (!this._idlMemberApplies("selectionStart")) {
+      return null;
+    }
+
+    return this._selectionStart;
+  }
+
+  set selectionStart(start) {
+    if (!this._idlMemberApplies("selectionStart")) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    this.setSelectionRange(start, Math.max(start, this._selectionEnd), this._selectionDirection);
+  }
+
+  get selectionEnd() {
+    if (!this._idlMemberApplies("selectionEnd")) {
+      return null;
+    }
+
+    return this._selectionEnd;
+  }
+
+  set selectionEnd(end) {
+    if (!this._idlMemberApplies("selectionEnd")) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    this.setSelectionRange(this._selectionStart, end, this._selectionDirection);
+  }
+
+  get selectionDirection() {
+    if (!this._idlMemberApplies("selectionDirection")) {
+      return null;
+    }
+
+    return this._selectionDirection;
+  }
+
+  set selectionDirection(dir) {
+    if (!this._idlMemberApplies("selectionDirection")) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    this.setSelectionRange(this._selectionStart, this._selectionEnd, dir);
+  }
+
+  setSelectionRange(start, end, dir) {
+    if (!this._idlMemberApplies("setSelectionRange")) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    this._selectionEnd = Math.min(end, this._getValueLength());
+    this._selectionStart = Math.min(start, this._selectionEnd);
+    this._selectionDirection = dir === "forward" || dir === "backward" ? dir : "none";
+    this._dispatchSelectEvent();
+  }
+
+  setRangeText(repl, start, end, selectionMode = "preserve") {
+    if (!this._idlMemberApplies("setRangeText")) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    if (arguments.length < 2) {
+      start = this._selectionStart;
+      end = this._selectionEnd;
+    } else if (start > end) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    start = Math.min(start, this._getValueLength());
+    end = Math.min(end, this._getValueLength());
+
+    const val = this.value;
+    let selStart = this._selectionStart;
+    let selEnd = this._selectionEnd;
+
+    this.value = val.slice(0, start) + repl + val.slice(end);
+
+    const newEnd = start + this.value.length;
+
+    if (selectionMode === "select") {
+      this.setSelectionRange(start, newEnd);
+    } else if (selectionMode === "start") {
+      this.setSelectionRange(start, start);
+    } else if (selectionMode === "end") {
+      this.setSelectionRange(newEnd, newEnd);
+    } else { // preserve
+      const delta = repl.length - (end - start);
+
+      if (selStart > end) {
+        selStart += delta;
+      } else if (selStart > start) {
+        selStart = start;
+      }
+
+      if (selEnd > end) {
+        selEnd += delta;
+      } else if (selEnd > start) {
+        selEnd = newEnd;
+      }
+
+      this.setSelectionRange(selStart, selEnd);
+    }
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#the-list-attribute
+  get list() {
+    const id = this._getAttributeIfApplies("list");
+    if (!id) {
+      return null;
+    }
+
+    const el = this.getRootNode({}).getElementById(id);
+
+    if (el && el.localName === "datalist") {
+      return el;
+    }
+
+    return null;
+  }
+
+  set maxLength(value) {
+    if (value < 0) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    this.setAttributeNS(null, "maxlength", String(value));
+  }
+
+  // Reflected IDL attribute does not care about whether the content attribute applies.
+  get maxLength() {
+    if (!this.hasAttributeNS(null, "maxlength")) {
+      return 524288; // stole this from chrome
+    }
+    return parseInt(this.getAttributeNS(null, "maxlength"));
+  }
+
+  set minLength(value) {
+    if (value < 0) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    this.setAttributeNS(null, "minlength", String(value));
+  }
+
+  get minLength() {
+    if (!this.hasAttributeNS(null, "minlength")) {
+      return 0;
+    }
+    return parseInt(this.getAttributeNS(null, "minlength"));
+  }
+
+  get size() {
+    if (!this.hasAttributeNS(null, "size")) {
+      return 20;
+    }
+    return parseInt(this.getAttributeNS(null, "size"));
+  }
+
+  set size(value) {
+    if (value <= 0) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    this.setAttributeNS(null, "size", String(value));
+  }
+
+  get src() {
+    return conversions.USVString(this.getAttributeNS(null, "src"));
+  }
+
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#the-min-and-max-attributes
+  get _minimum() {
+    let min = this._defaultMinimum;
+    const attr = this._getAttributeIfApplies("min");
+    if (attr !== null && this._convertStringToNumber !== undefined) {
+      const parsed = this._convertStringToNumber(attr);
+      if (parsed !== null) {
+        min = parsed;
+      }
+    }
+    return min;
+  }
+
+  get _maximum() {
+    let max = this._defaultMaximum;
+    const attr = this._getAttributeIfApplies("max");
+    if (attr !== null && this._convertStringToNumber !== undefined) {
+      const parsed = this._convertStringToNumber(attr);
+      if (parsed !== null) {
+        max = parsed;
+      }
+    }
+    return max;
+  }
+
+  get _defaultMinimum() {
+    if (this.type === "range") {
+      return 0;
+    }
+    return null;
+  }
+
+  get _defaultMaximum() {
+    if (this.type === "range") {
+      return 100;
+    }
+    return null;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-step
+  get _allowedValueStep() {
+    if (!this._contentAttributeApplies("step")) {
+      return null;
+    }
+    const attr = this.getAttributeNS(null, "step");
+    if (attr === null) {
+      return this._defaultStep * this._stepScaleFactor;
+    }
+    if (asciiCaseInsensitiveMatch(attr, "any")) {
+      return null;
+    }
+    const parsedStep = parseFloatingPointNumber(attr);
+    if (parsedStep === null || parsedStep <= 0) {
+      return this._defaultStep * this._stepScaleFactor;
+    }
+    return parsedStep * this._stepScaleFactor;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-step-scale
+  get _stepScaleFactor() {
+    const dayInMilliseconds = 24 * 60 * 60 * 1000;
+    switch (this.type) {
+      case "week":
+        return 7 * dayInMilliseconds;
+      case "date":
+        return dayInMilliseconds;
+      case "datetime-local":
+      case "datetime":
+      case "time":
+        return 1000;
+    }
+    return 1;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-step-default
+  get _defaultStep() {
+    if (this.type === "datetime-local" || this.type === "datetime" || this.type === "time") {
+      return 60;
+    }
+    return 1;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-min-zero
+  get _stepBase() {
+    if (this._hasAttributeAndApplies("min")) {
+      const min = this._convertStringToNumber(this.getAttributeNS(null, "min"));
+      if (min !== null) {
+        return min;
+      }
+    }
+    if (this.hasAttributeNS(null, "value")) {
+      const value = this._convertStringToNumber(this.getAttributeNS(null, "value"));
+      if (value !== null) {
+        return value;
+      }
+    }
+    if (this._defaultStepBase !== null) {
+      return this._defaultStepBase;
+    }
+    return 0;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-step-default-base
+  get _defaultStepBase() {
+    if (this.type === "week") {
+      // The start of week 1970-W01
+      return -259200000;
+    }
+    return null;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#common-input-element-attributes
+  // When an attribute doesn't apply to an input element, user agents must ignore the attribute.
+  _contentAttributeApplies(attribute) {
+    return applicableTypesForContentAttribute[attribute].has(this.type);
+  }
+
+  _hasAttributeAndApplies(attribute) {
+    return this._contentAttributeApplies(attribute) && this.hasAttributeNS(null, attribute);
+  }
+
+  _getAttributeIfApplies(attribute) {
+    if (this._contentAttributeApplies(attribute)) {
+      return this.getAttributeNS(null, attribute);
+    }
+    return null;
+  }
+
+  _idlMemberApplies(member, type = this.type) {
+    return applicableTypesForIDLMember[member].has(type);
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    // https://html.spec.whatwg.org/multipage/input.html#hidden-state-(type=hidden)
+    // https://html.spec.whatwg.org/multipage/input.html#reset-button-state-(type=reset)
+    // https://html.spec.whatwg.org/multipage/input.html#button-state-(type=button)
+    const willNotValidateTypes = new Set(["hidden", "reset", "button"]);
+    // https://html.spec.whatwg.org/multipage/input.html#attr-input-readonly
+    const readOnly = this._hasAttributeAndApplies("readonly");
+
+    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-disabled
+    return willNotValidateTypes.has(this.type) || readOnly;
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#concept-input-required
+  get _required() {
+    return this._hasAttributeAndApplies("required");
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#has-a-periodic-domain
+  get _hasAPeriodicDomain() {
+    return this.type === "time";
+  }
+
+  // https://html.spec.whatwg.org/multipage/input.html#has-a-reversed-range
+  get _hasAReversedRange() {
+    return this._hasAPeriodicDomain && this._maximum < this._minimum;
+  }
+
+  get validity() {
+    if (!this._validity) {
+      // Constraint validation: When an element has a reversed range, and the result of applying
+      // the algorithm to convert a string to a number to the string given by the element's value
+      // is a number, and the number obtained from that algorithm is more than the maximum and less
+      // than the minimum, the element is simultaneously suffering from an underflow and suffering
+      // from an overflow.
+      const reversedRangeSufferingOverUnderflow = () => {
+        const parsedValue = this._convertStringToNumber(this._value);
+        return parsedValue !== null && parsedValue > this._maximum && parsedValue < this._minimum;
+      };
+
+      const state = {
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-being-missing
+        valueMissing: () => {
+          // https://html.spec.whatwg.org/multipage/input.html#the-required-attribute
+          // Constraint validation: If the element is required, and its value IDL attribute applies
+          // and is in the mode value, and the element is mutable, and the element's value is the
+          // empty string, then the element is suffering from being missing.
+          //
+          // Note: As of today, the value IDL attribute always applies.
+          if (this._required && valueAttributeMode(this.type) === "value" && this._mutable && this._value === "") {
+            return true;
+          }
+
+          switch (this.type) {
+            // https://html.spec.whatwg.org/multipage/input.html#checkbox-state-(type=checkbox)
+            // Constraint validation: If the element is required and its checkedness is
+            // false, then the element is suffering from being missing.
+            case "checkbox":
+              if (this._required && !this._checkedness) {
+                return true;
+              }
+              break;
+
+            // https://html.spec.whatwg.org/multipage/input.html#radio-button-state-(type=radio)
+            // Constraint validation: If an element in the radio button group is required,
+            // and all of the input elements in the radio button group have a checkedness
+            // that is false, then the element is suffering from being missing.
+            case "radio":
+              if (this._required && !this._isRadioGroupChecked()) {
+                return true;
+              }
+              break;
+
+            // https://html.spec.whatwg.org/multipage/input.html#file-upload-state-(type=file)
+            // Constraint validation: If the element is required and the list of selected files is
+            // empty, then the element is suffering from being missing.
+            case "file":
+              if (this._required && this.files.length === 0) {
+                return true;
+              }
+              break;
+          }
+
+          return false;
+        },
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-being-too-long
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-maxlength
+        // jsdom has no way at the moment to emulate a user interaction, so tooLong/tooShort have
+        // to be set to false.
+        tooLong: () => false,
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-being-too-short
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-minlength
+        tooShort: () => false,
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-an-overflow
+        rangeOverflow: () => {
+          // https://html.spec.whatwg.org/multipage/input.html#the-min-and-max-attributes
+          if (this._hasAReversedRange) {
+            return reversedRangeSufferingOverUnderflow();
+          }
+          // Constraint validation: When the element has a maximum and does not have a reversed
+          // range, and the result of applying the algorithm to convert a string to a number to the
+          // string given by the element's value is a number, and the number obtained from that
+          // algorithm is more than the maximum, the element is suffering from an overflow.
+          if (this._maximum !== null) {
+            const parsedValue = this._convertStringToNumber(this._value);
+            if (parsedValue !== null && parsedValue > this._maximum) {
+              return true;
+            }
+          }
+          return false;
+        },
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-an-underflow
+        rangeUnderflow: () => {
+          // https://html.spec.whatwg.org/multipage/input.html#the-min-and-max-attributes
+          if (this._hasAReversedRange) {
+            return reversedRangeSufferingOverUnderflow();
+          }
+          // Constraint validation: When the element has a minimum and does not have a reversed
+          // range, and the result of applying the algorithm to convert a string to a number to the
+          // string given by the element's value is a number, and the number obtained from that
+          // algorithm is less than the minimum, the element is suffering from an underflow.
+          if (this._minimum !== null) {
+            const parsedValue = this._convertStringToNumber(this._value);
+            if (parsedValue !== null && parsedValue < this._minimum) {
+              return true;
+            }
+          }
+          return false;
+        },
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-a-pattern-mismatch
+        patternMismatch: () => {
+          // https://html.spec.whatwg.org/multipage/input.html#the-pattern-attribute
+          if (this._value === "" || !this._hasAttributeAndApplies("pattern")) {
+            return false;
+          }
+          let regExp;
+          try {
+            const pattern = this.getAttributeNS(null, "pattern");
+            // The pattern attribute should be matched against the entire value, not just any
+            // subset, so add ^ and $ anchors. But also check the validity of the regex itself
+            // first.
+            new RegExp(pattern, "u"); // eslint-disable-line no-new
+            regExp = new RegExp("^(?:" + pattern + ")$", "u");
+          } catch (e) {
+            return false;
+          }
+          if (this._hasAttributeAndApplies("multiple")) {
+            return !splitOnCommas(this._value).every(value => regExp.test(value));
+          }
+          return !regExp.test(this._value);
+        },
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-a-step-mismatch
+        // https://html.spec.whatwg.org/multipage/input.html#attr-input-step
+        stepMismatch: () => {
+          const allowedValueStep = this._allowedValueStep;
+          if (allowedValueStep === null) {
+            return false;
+          }
+          const number = this._convertStringToNumber(this._value);
+          return number !== null && !this._isStepAligned(number);
+        },
+
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-a-type-mismatch
+        typeMismatch: () => {
+          switch (this.type) {
+            // https://html.spec.whatwg.org/multipage/input.html#url-state-(type=url)
+            // Constraint validation: While the value of the element is neither the empty string
+            // nor a valid absolute URL, the element is suffering from a type mismatch.
+            case "url":
+              if (this._value !== "" && !isValidAbsoluteURL(this._value)) {
+                return true;
+              }
+              break;
+
+            // https://html.spec.whatwg.org/multipage/input.html#e-mail-state-(type=email)
+            // Constraint validation [multiple=false]: While the value of the element is neither the empty
+            // string nor a single valid e - mail address, the element is suffering from a type mismatch.
+            // Constraint validation [multiple=true]: While the value of the element is not a valid e-mail address list,
+            // the element is suffering from a type mismatch.
+            case "email":
+              if (this._value !== "" && !isValidEmailAddress(this._getValue(), this.hasAttributeNS(null, "multiple"))) {
+                return true;
+              }
+              break;
+          }
+          return false;
+        }
+      };
+
+      this._validity = ValidityState.createImpl(this._globalObject, [], {
+        element: this,
+        state
+      });
+    }
+    return this._validity;
+  }
+
+  [cloningSteps](copy, node) {
+    copy._value = node._value;
+    copy._checkedness = node._checkedness;
+    copy._dirtyValue = node._dirtyValue;
+    copy._dirtyCheckedness = node._dirtyCheckedness;
+  }
+}
+
+mixin(HTMLInputElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLInputElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLLIElement-impl.js b/lib/jsdom/living/nodes/HTMLLIElement-impl.js
new file mode 100644
index 0000000..e592582
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLLIElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLLIElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLLIElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLLabelElement-impl.js b/lib/jsdom/living/nodes/HTMLLabelElement-impl.js
new file mode 100644
index 0000000..399f487
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLLabelElement-impl.js
@@ -0,0 +1,73 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const MouseEvent = require("../generated/MouseEvent");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+const { isLabelable, isDisabled } = require("../helpers/form-controls");
+const { fireAnEvent } = require("../helpers/events");
+
+function sendClickToAssociatedNode(node) {
+  fireAnEvent("click", node, MouseEvent, {
+    bubbles: true,
+    cancelable: true,
+    view: node.ownerDocument ? node.ownerDocument.defaultView : null,
+    screenX: 0,
+    screenY: 0,
+    clientX: 0,
+    clientY: 0,
+    button: 0,
+    detail: 1,
+    relatedTarget: null
+  });
+}
+
+class HTMLLabelElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._hasActivationBehavior = true;
+  }
+
+  get control() {
+    if (this.hasAttributeNS(null, "for")) {
+      const forValue = this.getAttributeNS(null, "for");
+      if (forValue === "") {
+        return null;
+      }
+      const root = this.getRootNode({});
+      for (const descendant of domSymbolTree.treeIterator(root)) {
+        if (descendant.nodeType === NODE_TYPE.ELEMENT_NODE &&
+          descendant.getAttributeNS(null, "id") === forValue) {
+          return isLabelable(descendant) ? descendant : null;
+        }
+      }
+      return null;
+    }
+    for (const descendant of domSymbolTree.treeIterator(this)) {
+      if (isLabelable(descendant)) {
+        return descendant;
+      }
+    }
+    return null;
+  }
+
+  get form() {
+    const node = this.control;
+    if (node) {
+      return node.form;
+    }
+    return null;
+  }
+
+  _activationBehavior() {
+    const node = this.control;
+    if (node && !isDisabled(node)) {
+      sendClickToAssociatedNode(node);
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLLabelElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLLegendElement-impl.js b/lib/jsdom/living/nodes/HTMLLegendElement-impl.js
new file mode 100644
index 0000000..5842a2a
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLLegendElement-impl.js
@@ -0,0 +1,13 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { formOwner } = require("../helpers/form-controls");
+
+class HTMLLegendElementImpl extends HTMLElementImpl {
+  get form() {
+    return formOwner(this);
+  }
+}
+
+module.exports = {
+  implementation: HTMLLegendElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLLinkElement-impl.js b/lib/jsdom/living/nodes/HTMLLinkElement-impl.js
new file mode 100644
index 0000000..5ec9415
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLLinkElement-impl.js
@@ -0,0 +1,110 @@
+"use strict";
+const { reflectURLAttribute } = require("../../utils");
+const DOMTokenList = require("../generated/DOMTokenList");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const idlUtils = require("../generated/utils");
+const { fetchStylesheet } = require("../helpers/stylesheets");
+const { parseURLToResultingURLRecord } = require("../helpers/document-base-url");
+const whatwgURL = require("whatwg-url");
+
+// Important reading: "appropriate times to obtain the resource" in
+// https://html.spec.whatwg.org/multipage/semantics.html#link-type-stylesheet
+
+class HTMLLinkElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.sheet = null;
+  }
+
+  get relList() {
+    if (this._relList === undefined) {
+      this._relList = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "rel",
+        supportedTokens: new Set(["stylesheet"])
+      });
+    }
+    return this._relList;
+  }
+
+  _attach() {
+    super._attach();
+    maybeFetchAndProcess(this);
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "href") { // TODO crossorigin="" or type=""
+      maybeFetchAndProcess(this);
+    }
+
+    if (name === "rel" && this._relList !== undefined) {
+      this._relList.attrModified();
+    }
+  }
+
+  get _accept() {
+    return "text/css,*/*;q=0.1";
+  }
+
+  get href() {
+    return reflectURLAttribute(this, "href");
+  }
+
+  set href(value) {
+    this.setAttributeNS(null, "href", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLLinkElementImpl
+};
+
+// https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
+function maybeFetchAndProcess(el) {
+  if (!isExternalResourceLink(el)) {
+    return;
+  }
+
+  // Browsing-context connected
+  if (!el.isConnected || !el._ownerDocument._defaultView) {
+    return;
+  }
+
+  fetchAndProcess(el);
+}
+
+// https://html.spec.whatwg.org/multipage/semantics.html#default-fetch-and-process-the-linked-resource
+// TODO: refactor into general link-fetching like the spec.
+function fetchAndProcess(el) {
+  const href = el.getAttributeNS(null, "href");
+
+  if (href === null || href === "") {
+    return;
+  }
+
+  const url = parseURLToResultingURLRecord(href, el._ownerDocument);
+  if (url === null) {
+    return;
+  }
+
+  // TODO handle crossorigin="", nonce, integrity="", referrerpolicy=""
+
+  const serialized = whatwgURL.serializeURL(url);
+
+  fetchStylesheet(el, serialized);
+}
+
+function isExternalResourceLink(el) {
+  // for our purposes, only stylesheets can be external resource links
+  const wrapper = idlUtils.wrapperForImpl(el);
+  if (!/(?:[ \t\n\r\f]|^)stylesheet(?:[ \t\n\r\f]|$)/i.test(wrapper.rel)) {
+    // rel is a space-separated list of tokens, and the original rel types
+    // are case-insensitive.
+    return false;
+  }
+
+  return Boolean(el.href);
+}
diff --git a/lib/jsdom/living/nodes/HTMLMapElement-impl.js b/lib/jsdom/living/nodes/HTMLMapElement-impl.js
new file mode 100644
index 0000000..b431dad
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLMapElement-impl.js
@@ -0,0 +1,13 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLMapElementImpl extends HTMLElementImpl {
+  get areas() {
+    return this.getElementsByTagName("AREA");
+  }
+}
+
+module.exports = {
+  implementation: HTMLMapElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLMarqueeElement-impl.js b/lib/jsdom/living/nodes/HTMLMarqueeElement-impl.js
new file mode 100644
index 0000000..66371cb
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLMarqueeElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLMarqueeElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLMarqueeElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLMediaElement-impl.js b/lib/jsdom/living/nodes/HTMLMediaElement-impl.js
new file mode 100644
index 0000000..47f13a9
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLMediaElement-impl.js
@@ -0,0 +1,137 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const notImplemented = require("../../browser/not-implemented");
+const { reflectURLAttribute } = require("../../utils");
+const { fireAnEvent } = require("../helpers/events");
+
+function getTimeRangeDummy() {
+  return {
+    length: 0,
+    start() {
+      return 0;
+    },
+    end() {
+      return 0;
+    }
+  };
+}
+
+class HTMLMediaElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._muted = false;
+    this._volume = 1.0;
+    this.readyState = 0;
+    this.networkState = 0;
+    this.currentTime = 0;
+    this.currentSrc = "";
+    this.buffered = getTimeRangeDummy();
+    this.seeking = false;
+    this.duration = NaN;
+    this.paused = true;
+    this.played = getTimeRangeDummy();
+    this.seekable = getTimeRangeDummy();
+    this.ended = false;
+    this.audioTracks = [];
+    this.videoTracks = [];
+    this.textTracks = [];
+  }
+  // Implemented accoring to W3C Draft 22 August 2012
+  set defaultPlaybackRate(v) {
+    if (v === 0.0) {
+      throw DOMException.create(this._globalObject, ["The operation is not supported.", "NotSupportedError"]);
+    }
+    if (this._defaultPlaybackRate !== v) {
+      this._defaultPlaybackRate = v;
+      this._dispatchRateChange();
+    }
+  }
+
+  _dispatchRateChange() {
+    fireAnEvent("ratechange", this);
+  }
+  get defaultPlaybackRate() {
+    if (this._defaultPlaybackRate === undefined) {
+      return 1.0;
+    }
+    return this._defaultPlaybackRate;
+  }
+  get playbackRate() {
+    if (this._playbackRate === undefined) {
+      return 1.0;
+    }
+    return this._playbackRate;
+  }
+  set playbackRate(v) {
+    if (v !== this._playbackRate) {
+      this._playbackRate = v;
+      this._dispatchRateChange();
+    }
+  }
+  get muted() {
+    return this._muted;
+  }
+  _dispatchVolumeChange() {
+    fireAnEvent("volumechange", this);
+  }
+  set muted(v) {
+    if (v !== this._muted) {
+      this._muted = v;
+      this._dispatchVolumeChange();
+    }
+  }
+  get defaultMuted() {
+    return this.getAttributeNS(null, "muted") !== null;
+  }
+  set defaultMuted(v) {
+    if (v) {
+      this.setAttributeNS(null, "muted", v);
+    } else {
+      this.removeAttributeNS(null, "muted");
+    }
+  }
+  get volume() {
+    return this._volume;
+  }
+  set volume(v) {
+    if (v < 0 || v > 1) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    if (this._volume !== v) {
+      this._volume = v;
+      this._dispatchVolumeChange();
+    }
+  }
+
+  // Not (yet) implemented according to spec
+  // Should return sane default values
+  load() {
+    notImplemented("HTMLMediaElement.prototype.load", this._ownerDocument._defaultView);
+  }
+  canPlayType() {
+    return "";
+  }
+  play() {
+    notImplemented("HTMLMediaElement.prototype.play", this._ownerDocument._defaultView);
+  }
+  pause() {
+    notImplemented("HTMLMediaElement.prototype.pause", this._ownerDocument._defaultView);
+  }
+  addTextTrack() {
+    notImplemented("HTMLMediaElement.prototype.addTextTrack", this._ownerDocument._defaultView);
+  }
+
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLMediaElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLMenuElement-impl.js b/lib/jsdom/living/nodes/HTMLMenuElement-impl.js
new file mode 100644
index 0000000..4faf848
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLMenuElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLMenuElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLMenuElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLMetaElement-impl.js b/lib/jsdom/living/nodes/HTMLMetaElement-impl.js
new file mode 100644
index 0000000..ff038f2
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLMetaElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLMetaElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLMetaElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLMeterElement-impl.js b/lib/jsdom/living/nodes/HTMLMeterElement-impl.js
new file mode 100644
index 0000000..25aeef0
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLMeterElement-impl.js
@@ -0,0 +1,180 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { parseFloatingPointNumber } = require("../helpers/strings");
+const { getLabelsForLabelable } = require("../helpers/form-controls");
+
+class HTMLMeterElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._labels = null;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-meter-minimum
+  get _minimumValue() {
+    const min = this.getAttributeNS(null, "min");
+    if (min !== null) {
+      const parsed = parseFloatingPointNumber(min);
+      if (parsed !== null) {
+        return parsed;
+      }
+    }
+    return 0;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-meter-maximum
+  get _maximumValue() {
+    let candidate = 1.0;
+
+    const max = this.getAttributeNS(null, "max");
+    if (max !== null) {
+      const parsed = parseFloatingPointNumber(max);
+      if (parsed !== null) {
+        candidate = parsed;
+      }
+    }
+
+    const minimumValue = this._minimumValue;
+    return candidate >= minimumValue ? candidate : minimumValue;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-meter-actual
+  get _actualValue() {
+    let candidate = 0;
+
+    const value = this.getAttributeNS(null, "value");
+    if (value !== null) {
+      const parsed = parseFloatingPointNumber(value);
+      if (parsed !== null) {
+        candidate = parsed;
+      }
+    }
+
+    const minimumValue = this._minimumValue;
+    if (candidate < minimumValue) {
+      return minimumValue;
+    }
+
+    const maximumValue = this._maximumValue;
+    return candidate > maximumValue ? maximumValue : candidate;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-meter-low
+  get _lowBoundary() {
+    const minimumValue = this._minimumValue;
+    let candidate = minimumValue;
+
+    const low = this.getAttributeNS(null, "low");
+    if (low !== null) {
+      const parsed = parseFloatingPointNumber(low);
+      if (parsed !== null) {
+        candidate = parsed;
+      }
+    }
+
+    if (candidate < minimumValue) {
+      return minimumValue;
+    }
+
+    const maximumValue = this._maximumValue;
+    return candidate > maximumValue ? maximumValue : candidate;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-meter-high
+  get _highBoundary() {
+    const maximumValue = this._maximumValue;
+    let candidate = maximumValue;
+
+    const high = this.getAttributeNS(null, "high");
+    if (high !== null) {
+      const parsed = parseFloatingPointNumber(high);
+      if (parsed !== null) {
+        candidate = parsed;
+      }
+    }
+
+    const lowBoundary = this._lowBoundary;
+    if (candidate < lowBoundary) {
+      return lowBoundary;
+    }
+
+    return candidate > maximumValue ? maximumValue : candidate;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-meter-optimum
+  get _optimumPoint() {
+    const minimumValue = this._minimumValue;
+    const maximumValue = this._maximumValue;
+    let candidate = (minimumValue + maximumValue) / 2;
+
+    const optimum = this.getAttributeNS(null, "optimum");
+    if (optimum !== null) {
+      const parsed = parseFloatingPointNumber(optimum);
+      if (parsed !== null) {
+        candidate = parsed;
+      }
+    }
+
+    if (candidate < minimumValue) {
+      return minimumValue;
+    }
+
+    return candidate > maximumValue ? maximumValue : candidate;
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get value() {
+    return this._actualValue;
+  }
+
+  set value(val) {
+    this.setAttributeNS(null, "value", String(val));
+  }
+
+  get min() {
+    return this._minimumValue;
+  }
+
+  set min(val) {
+    this.setAttributeNS(null, "min", String(val));
+  }
+
+  get max() {
+    return this._maximumValue;
+  }
+
+  set max(val) {
+    this.setAttributeNS(null, "max", String(val));
+  }
+
+  get low() {
+    return this._lowBoundary;
+  }
+
+  set low(val) {
+    this.setAttributeNS(null, "low", String(val));
+  }
+
+  get high() {
+    return this._highBoundary;
+  }
+
+  set high(val) {
+    this.setAttributeNS(null, "high", String(val));
+  }
+
+  get optimum() {
+    return this._optimumPoint;
+  }
+
+  set optimum(val) {
+    this.setAttributeNS(null, "optimum", String(val));
+  }
+}
+
+module.exports = {
+  implementation: HTMLMeterElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLModElement-impl.js b/lib/jsdom/living/nodes/HTMLModElement-impl.js
new file mode 100644
index 0000000..26a8645
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLModElement-impl.js
@@ -0,0 +1,18 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLModElementImpl extends HTMLElementImpl {
+  get cite() {
+    return conversions.USVString(this.getAttributeNS(null, "cite"));
+  }
+
+  set cite(value) {
+    this.setAttributeNS(null, "cite", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLModElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLOListElement-impl.js b/lib/jsdom/living/nodes/HTMLOListElement-impl.js
new file mode 100644
index 0000000..b7d207f
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLOListElement-impl.js
@@ -0,0 +1,22 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLOListElementImpl extends HTMLElementImpl {
+  get start() {
+    const value = parseInt(this.getAttributeNS(null, "start"));
+
+    if (!isNaN(value)) {
+      return value;
+    }
+
+    return 1;
+  }
+  set start(value) {
+    this.setAttributeNS(null, "start", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLOListElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLObjectElement-impl.js b/lib/jsdom/living/nodes/HTMLObjectElement-impl.js
new file mode 100644
index 0000000..1a27751
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLObjectElement-impl.js
@@ -0,0 +1,43 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { mixin } = require("../../utils");
+const { reflectURLAttribute } = require("../../utils");
+const { formOwner } = require("../helpers/form-controls");
+
+class HTMLObjectElementImpl extends HTMLElementImpl {
+  get form() {
+    return formOwner(this);
+  }
+
+  get contentDocument() {
+    return null;
+  }
+
+  get data() {
+    return reflectURLAttribute(this, "data");
+  }
+
+  set data(V) {
+    this.setAttributeNS(null, "data", V);
+  }
+
+  get codeBase() {
+    return reflectURLAttribute(this, "codebase");
+  }
+
+  set codeBase(V) {
+    this.setAttributeNS(null, "codebase", V);
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return true;
+  }
+}
+
+mixin(HTMLObjectElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLObjectElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLOptGroupElement-impl.js b/lib/jsdom/living/nodes/HTMLOptGroupElement-impl.js
new file mode 100644
index 0000000..28d9348
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLOptGroupElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLOptGroupElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLOptGroupElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLOptionElement-impl.js b/lib/jsdom/living/nodes/HTMLOptionElement-impl.js
new file mode 100644
index 0000000..dd28ba1
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLOptionElement-impl.js
@@ -0,0 +1,129 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { stripAndCollapseASCIIWhitespace } = require("../helpers/strings");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { closest } = require("../helpers/traversal");
+const { formOwner } = require("../helpers/form-controls");
+
+class HTMLOptionElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    // whenever selectedness is set to true, make sure all
+    // other options set selectedness to false
+    this._selectedness = false;
+    this._dirtyness = false;
+  }
+
+  _removeOtherSelectedness() {
+    // Remove the selectedness flag from all other options in this select
+    const select = this._selectNode;
+
+    if (select && !select.hasAttributeNS(null, "multiple")) {
+      for (const option of select.options) {
+        if (option !== this) {
+          option._selectedness = false;
+        }
+      }
+    }
+  }
+
+  _askForAReset() {
+    const select = this._selectNode;
+    if (select) {
+      select._askedForAReset();
+    }
+  }
+
+  _attrModified(name) {
+    if (!this._dirtyness && name === "selected") {
+      this._selectedness = this.hasAttributeNS(null, "selected");
+      if (this._selectedness) {
+        this._removeOtherSelectedness();
+      }
+      this._askForAReset();
+    }
+    super._attrModified.apply(this, arguments);
+  }
+
+  get _selectNode() {
+    let select = domSymbolTree.parent(this);
+    if (!select) {
+      return null;
+    }
+
+    if (select.nodeName.toUpperCase() !== "SELECT") {
+      select = domSymbolTree.parent(select);
+      if (!select || select.nodeName.toUpperCase() !== "SELECT") {
+        return null;
+      }
+    }
+    return select;
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get text() {
+    // TODO is not correctly excluding script and SVG script descendants
+    return stripAndCollapseASCIIWhitespace(this.textContent);
+  }
+  set text(value) {
+    this.textContent = value;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-option-value
+  _getValue() {
+    if (this.hasAttributeNS(null, "value")) {
+      return this.getAttributeNS(null, "value");
+    }
+
+    return this.text;
+  }
+
+  get value() {
+    return this._getValue();
+  }
+  set value(value) {
+    this.setAttributeNS(null, "value", value);
+  }
+
+  get index() {
+    const select = closest(this, "select");
+    if (select === null) {
+      return 0;
+    }
+
+    return select.options.indexOf(this);
+  }
+
+  get selected() {
+    return this._selectedness;
+  }
+  set selected(s) {
+    this._dirtyness = true;
+    this._selectedness = Boolean(s);
+    if (this._selectedness) {
+      this._removeOtherSelectedness();
+    }
+    this._askForAReset();
+    this._modified();
+  }
+
+  get label() {
+    if (this.hasAttributeNS(null, "label")) {
+      return this.getAttributeNS(null, "label");
+    }
+
+    return this.text;
+  }
+  set label(value) {
+    this.setAttributeNS(null, "label", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLOptionElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLOptionsCollection-impl.js b/lib/jsdom/living/nodes/HTMLOptionsCollection-impl.js
new file mode 100644
index 0000000..67d51e7
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLOptionsCollection-impl.js
@@ -0,0 +1,110 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_CONTAINED_BY } = require("../node-document-position");
+const Element = require("../generated/Element");
+const Node = require("../generated/Node");
+const HTMLCollectionImpl = require("./HTMLCollection-impl").implementation;
+
+exports.implementation = class HTMLOptionsCollectionImpl extends HTMLCollectionImpl {
+  // inherits supported property indices
+  get length() {
+    this._update();
+    return this._list.length;
+  }
+  set length(value) {
+    this._update();
+    if (value > this._list.length) {
+      const doc = this._element._ownerDocument;
+      for (let i = this._list.length; i < value; i++) {
+        const el = doc.createElement("option");
+        this._element.appendChild(el);
+      }
+    } else if (value < this._list.length) {
+      for (let i = this._list.length - 1; i >= value; i--) {
+        const el = this._list[i];
+        this._element.removeChild(el);
+      }
+    }
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    this._update();
+    const result = new Set();
+    for (const element of this._list) {
+      result.add(element.getAttributeNS(null, "id"));
+      result.add(element.getAttributeNS(null, "name"));
+    }
+    return result;
+  }
+  [idlUtils.indexedSetNew](index, value) {
+    if (value === null) {
+      this.remove(index);
+      return;
+    }
+    this._update();
+    const { length } = this._list;
+    const n = index - length;
+    if (n > 0) {
+      const doc = this._element._ownerDocument;
+      const frag = doc.createDocumentFragment();
+      // Spec says n - 1, but n seems to be the right number here.
+      for (let i = 0; i < n; i++) {
+        const el = doc.createElement("option");
+        frag.appendChild(el);
+      }
+      this._element._append(frag);
+    }
+    if (n >= 0) {
+      this._element._append(value);
+    } else {
+      this._element._replace(value, this._list[index]);
+    }
+  }
+  [idlUtils.indexedSetExisting](index, value) {
+    return this[idlUtils.indexedSetNew](index, value);
+  }
+  add(element, before) {
+    if (this._element.compareDocumentPosition(element) & DOCUMENT_POSITION_CONTAINS) {
+      throw DOMException.create(this._globalObject, [
+        "The operation would yield an incorrect node tree.",
+        "HierarchyRequestError"
+      ]);
+    }
+    if (Element.isImpl(before) && !(this._element.compareDocumentPosition(before) & DOCUMENT_POSITION_CONTAINED_BY)) {
+      throw DOMException.create(this._globalObject, ["The object can not be found here.", "NotFoundError"]);
+    }
+    if (element === before) {
+      return;
+    }
+
+    let reference = null;
+    if (Node.isImpl(before)) {
+      reference = before;
+    } else if (typeof before === "number") {
+      this._update();
+      reference = this._list[before] || null;
+    }
+
+    const parent = reference !== null ? reference.parentNode : this._element;
+    parent._preInsert(element, reference);
+  }
+  remove(index) {
+    this._update();
+    if (this._list.length === 0) {
+      return;
+    }
+    if (index < 0 || index >= this._list.length) {
+      return;
+    }
+    const element = this._list[index];
+    element.parentNode._remove(element);
+  }
+  get selectedIndex() {
+    return this._element.selectedIndex;
+  }
+  set selectedIndex(value) {
+    this._element.selectedIndex = value;
+  }
+};
diff --git a/lib/jsdom/living/nodes/HTMLOrSVGElement-impl.js b/lib/jsdom/living/nodes/HTMLOrSVGElement-impl.js
new file mode 100644
index 0000000..8640bae
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLOrSVGElement-impl.js
@@ -0,0 +1,72 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const { isSummaryForParentDetails } = require("../helpers/details");
+const focusing = require("../helpers/focusing");
+const { HTML_NS, SVG_NS } = require("../helpers/namespaces");
+const DOMStringMap = require("../generated/DOMStringMap");
+
+const tabIndexReflectAllowedHTMLElements = new Set([
+  "a", "area", "button", "frame", "iframe",
+  "input", "object", "select", "textarea"
+]);
+
+class HTMLOrSVGElementImpl {
+  _initHTMLOrSVGElement() {
+    this._tabIndex = 0;
+    this._dataset = DOMStringMap.createImpl(this._globalObject, [], { element: this });
+  }
+
+  get dataset() {
+    return this._dataset;
+  }
+
+  // TODO this should be [Reflect]able if we added default value support to webidl2js's [Reflect]
+  get tabIndex() {
+    if (!this.hasAttributeNS(null, "tabindex")) {
+      if ((this.namespaceURI === HTML_NS && (tabIndexReflectAllowedHTMLElements.has(this._localName) ||
+                                             (this._localName === "summary" && isSummaryForParentDetails(this)))) ||
+          (this.namespaceURI === SVG_NS && this._localName === "a")) {
+        return 0;
+      }
+      return -1;
+    }
+    return conversions.long(this.getAttributeNS(null, "tabindex"));
+  }
+
+  set tabIndex(value) {
+    this.setAttributeNS(null, "tabindex", String(value));
+  }
+
+  focus() {
+    if (!focusing.isFocusableAreaElement(this)) {
+      return;
+    }
+
+    const previous = this._ownerDocument._lastFocusedElement;
+
+    if (previous === this) {
+      return;
+    }
+
+    focusing.fireFocusEventWithTargetAdjustment("blur", previous, this);
+    this._ownerDocument._lastFocusedElement = this;
+    focusing.fireFocusEventWithTargetAdjustment("focus", this, previous);
+
+    if (this._ownerDocument._defaultView._frameElement) {
+      this._ownerDocument._defaultView._frameElement.focus();
+    }
+  }
+
+  blur() {
+    if (this._ownerDocument._lastFocusedElement !== this || !focusing.isFocusableAreaElement(this)) {
+      return;
+    }
+
+    focusing.fireFocusEventWithTargetAdjustment("blur", this, this._ownerDocument);
+    this._ownerDocument._lastFocusedElement = null;
+    focusing.fireFocusEventWithTargetAdjustment("focus", this._ownerDocument, this);
+  }
+}
+
+exports.implementation = HTMLOrSVGElementImpl;
diff --git a/lib/jsdom/living/nodes/HTMLOutputElement-impl.js b/lib/jsdom/living/nodes/HTMLOutputElement-impl.js
new file mode 100644
index 0000000..f9d14d6
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLOutputElement-impl.js
@@ -0,0 +1,90 @@
+"use strict";
+
+const DOMTokenList = require("../generated/DOMTokenList");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { mixin } = require("../../utils");
+const { getLabelsForLabelable, formOwner } = require("../helpers/form-controls");
+
+class HTMLOutputElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._labels = null;
+    this._defaultValue = "";
+    this._valueMode = "default";
+
+    this._customValidityErrorMessage = "";
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (name === "for" && this._htmlFor !== undefined) {
+      this._htmlFor.attrModified();
+    }
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return true;
+  }
+
+  _formReset() {
+    if (this._valueMode === "value") {
+      this.textContent = this._defaultValue;
+    }
+
+    this._defaultValue = "";
+    this._valueMode = "default";
+  }
+
+  get htmlFor() {
+    if (this._htmlFor === undefined) {
+      this._htmlFor = DOMTokenList.createImpl(this._globalObject, [], {
+        element: this,
+        attributeLocalName: "for"
+      });
+    }
+    return this._htmlFor;
+  }
+
+  get type() {
+    return "output";
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get value() {
+    return this.textContent;
+  }
+
+  set value(val) {
+    this._valueMode = "value";
+    this._defaultValue = this.textContent;
+    this.textContent = val;
+  }
+
+  get defaultValue() {
+    return this._valueMode === "default" ? this.textContent : this._defaultValue;
+  }
+
+  set defaultValue(val) {
+    this._defaultValue = val;
+
+    if (this._valueMode === "default") {
+      this.textContent = val;
+    }
+  }
+}
+
+mixin(HTMLOutputElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLOutputElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLParagraphElement-impl.js b/lib/jsdom/living/nodes/HTMLParagraphElement-impl.js
new file mode 100644
index 0000000..01495c6
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLParagraphElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLParagraphElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLParagraphElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLParamElement-impl.js b/lib/jsdom/living/nodes/HTMLParamElement-impl.js
new file mode 100644
index 0000000..05e4f8c
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLParamElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLParamElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLParamElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLPictureElement-impl.js b/lib/jsdom/living/nodes/HTMLPictureElement-impl.js
new file mode 100644
index 0000000..6d2062f
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLPictureElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLPictureElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLPictureElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLPreElement-impl.js b/lib/jsdom/living/nodes/HTMLPreElement-impl.js
new file mode 100644
index 0000000..85b11db
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLPreElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLPreElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLPreElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLProgressElement-impl.js b/lib/jsdom/living/nodes/HTMLProgressElement-impl.js
new file mode 100644
index 0000000..5090442
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLProgressElement-impl.js
@@ -0,0 +1,74 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { getLabelsForLabelable } = require("../helpers/form-controls");
+const { parseFloatingPointNumber } = require("../helpers/strings");
+
+class HTMLProgressElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._labels = null;
+  }
+
+  get _isDeterminate() {
+    return this.hasAttributeNS(null, "value");
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-progress-value
+  get _value() {
+    const valueAttr = this.getAttributeNS(null, "value");
+    const parsedValue = parseFloatingPointNumber(valueAttr);
+    if (parsedValue !== null && parsedValue > 0) {
+      return parsedValue;
+    }
+    return 0;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#concept-progress-current-value
+  get _currentValue() {
+    const value = this._value;
+    return value > this.max ? this.max : value;
+  }
+
+  get value() {
+    if (this._isDeterminate) {
+      return this._currentValue;
+    }
+    return 0;
+  }
+  set value(value) {
+    this.setAttributeNS(null, "value", value);
+  }
+
+  get max() {
+    const max = this.getAttributeNS(null, "max");
+    if (max !== null) {
+      const parsedMax = parseFloatingPointNumber(max);
+      if (parsedMax !== null && parsedMax > 0) {
+        return parsedMax;
+      }
+    }
+    return 1.0;
+  }
+  set max(value) {
+    if (value > 0) {
+      this.setAttributeNS(null, "max", value);
+    }
+  }
+
+  get position() {
+    if (!this._isDeterminate) {
+      return -1;
+    }
+
+    return this._currentValue / this.max;
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+}
+
+module.exports = {
+  implementation: HTMLProgressElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLQuoteElement-impl.js b/lib/jsdom/living/nodes/HTMLQuoteElement-impl.js
new file mode 100644
index 0000000..2e96a2f
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLQuoteElement-impl.js
@@ -0,0 +1,18 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLQuoteElementImpl extends HTMLElementImpl {
+  get cite() {
+    return conversions.USVString(this.getAttributeNS(null, "cite"));
+  }
+
+  set cite(value) {
+    this.setAttributeNS(null, "cite", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLQuoteElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLScriptElement-impl.js b/lib/jsdom/living/nodes/HTMLScriptElement-impl.js
new file mode 100644
index 0000000..49e9200
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLScriptElement-impl.js
@@ -0,0 +1,265 @@
+"use strict";
+const vm = require("vm");
+const whatwgEncoding = require("whatwg-encoding");
+const MIMEType = require("whatwg-mimetype");
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { reflectURLAttribute } = require("../../utils");
+const reportException = require("../helpers/runtime-script-errors");
+const { domSymbolTree, cloningSteps } = require("../helpers/internal-constants");
+const { asciiLowercase } = require("../helpers/strings");
+const { childTextContent } = require("../helpers/text");
+const { fireAnEvent } = require("../helpers/events");
+const nodeTypes = require("../node-type");
+
+const jsMIMETypes = new Set([
+  "application/ecmascript",
+  "application/javascript",
+  "application/x-ecmascript",
+  "application/x-javascript",
+  "text/ecmascript",
+  "text/javascript",
+  "text/javascript1.0",
+  "text/javascript1.1",
+  "text/javascript1.2",
+  "text/javascript1.3",
+  "text/javascript1.4",
+  "text/javascript1.5",
+  "text/jscript",
+  "text/livescript",
+  "text/x-ecmascript",
+  "text/x-javascript"
+]);
+
+class HTMLScriptElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._alreadyStarted = false;
+    this._parserInserted = false; // set by the parser
+  }
+
+  _attach() {
+    super._attach();
+
+
+    // In our current terribly-hacky document.write() implementation, we parse in a div them move elements into the main
+    // document. Thus _eval() will bail early when it gets in _poppedOffStackOfOpenElements(), since we're not attached
+    // then. Instead, we'll let it eval here.
+    if (!this._parserInserted || this._isMovingDueToDocumentWrite) {
+      this._eval();
+    }
+  }
+
+  _canRunScript() {
+    const document = this._ownerDocument;
+    // Equivalent to the spec's "scripting is disabled" check.
+    if (!document._defaultView || document._defaultView._runScripts !== "dangerously" || document._scriptingDisabled) {
+      return false;
+    }
+
+    return true;
+  }
+
+  _fetchExternalScript(src) {
+    const document = this._ownerDocument;
+    const resourceLoader = document._resourceLoader;
+    const defaultEncoding = whatwgEncoding.labelToName(this.getAttributeNS(null, "charset")) || document._encoding;
+    let request;
+
+    if (!this._canRunScript()) {
+      return;
+    }
+
+    const onLoadExternalScript = data => {
+      const { response } = request;
+      let contentType;
+
+      if (response && response.statusCode !== undefined && response.statusCode >= 400) {
+        throw new Error("Status code: " + response.statusCode);
+      }
+
+      if (response) {
+        contentType = MIMEType.parse(response.headers["content-type"]) || new MIMEType("text/plain");
+      }
+
+      const encoding = whatwgEncoding.getBOMEncoding(data) ||
+        (contentType && whatwgEncoding.labelToName(contentType.parameters.get("charset"))) ||
+        defaultEncoding;
+      const script = whatwgEncoding.decode(data, encoding);
+
+      this._innerEval(script, this.src);
+    };
+
+    request = resourceLoader.fetch(src, {
+      element: this,
+      onLoad: onLoadExternalScript
+    });
+  }
+
+  _fetchInternalScript() {
+    const document = this._ownerDocument;
+
+    if (!this._canRunScript()) {
+      return;
+    }
+
+    document._queue.push(null, () => {
+      this._innerEval(this.text, document.URL);
+
+      fireAnEvent("load", this);
+    }, null, false, this);
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (this._attached && !this._startedEval && name === "src" && oldValue === null && value !== null) {
+      this._fetchExternalScript(this.src);
+    }
+  }
+
+  _poppedOffStackOfOpenElements() {
+    // This seems to roughly correspond to
+    // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incdata:prepare-a-script, although we certainly
+    // don't implement the full semantics.
+    this._eval();
+  }
+
+  // Vaguely similar to https://html.spec.whatwg.org/multipage/scripting.html#prepare-a-script, but we have a long way
+  // to go before it's aligned.
+  _eval() {
+    if (this._alreadyStarted) {
+      return;
+    }
+
+    // TODO: this text check doesn't seem completely the same as the spec, which e.g. will try to execute scripts with
+    // child element nodes. Spec bug? https://github.com/whatwg/html/issues/3419
+    if (!this.hasAttributeNS(null, "src") && this.text.length === 0) {
+      return;
+    }
+
+    if (!this._attached) {
+      return;
+    }
+
+    const scriptBlocksTypeString = this._getTypeString();
+    const type = getType(scriptBlocksTypeString);
+
+    if (type !== "classic") {
+      // TODO: implement modules, and then change the check to `type === null`.
+      return;
+    }
+
+    this._alreadyStarted = true;
+
+    // TODO: implement nomodule here, **but only after we support modules**.
+
+    // At this point we completely depart from the spec.
+
+    if (this.hasAttributeNS(null, "src")) {
+      this._fetchExternalScript(this.src);
+    } else {
+      this._fetchInternalScript();
+    }
+  }
+
+  _innerEval(text, filename) {
+    this._ownerDocument._writeAfterElement = this;
+    processJavaScript(this, text, filename);
+    delete this._ownerDocument._writeAfterElement;
+  }
+
+  _getTypeString() {
+    const typeAttr = this.getAttributeNS(null, "type");
+    const langAttr = this.getAttributeNS(null, "language");
+
+    if (typeAttr === "") {
+      return "text/javascript";
+    }
+
+    if (typeAttr === null && langAttr === "") {
+      return "text/javascript";
+    }
+
+    if (typeAttr === null && langAttr === null) {
+      return "text/javascript";
+    }
+
+    if (typeAttr !== null) {
+      return typeAttr.trim();
+    }
+
+    if (langAttr !== null) {
+      return "text/" + langAttr;
+    }
+
+    return null;
+  }
+
+  get text() {
+    return childTextContent(this);
+  }
+
+  set text(text) {
+    this.textContent = text;
+  }
+
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+
+  set src(V) {
+    this.setAttributeNS(null, "src", V);
+  }
+
+  // https://html.spec.whatwg.org/multipage/scripting.html#script-processing-model
+  [cloningSteps](copy, node) {
+    copy._alreadyStarted = node._alreadyStarted;
+  }
+}
+
+function processJavaScript(element, code, filename) {
+  const document = element.ownerDocument;
+  const window = document && document._global;
+
+  if (window) {
+    document._currentScript = element;
+
+    let lineOffset = 0;
+    if (!element.src) {
+      for (const child of domSymbolTree.childrenIterator(element)) {
+        if (child.nodeType === nodeTypes.TEXT_NODE) {
+          if (child.sourceCodeLocation) {
+            lineOffset = child.sourceCodeLocation.startLine - 1;
+          }
+          break;
+        }
+      }
+    }
+
+    try {
+      vm.runInContext(code, window, { filename, lineOffset, displayErrors: false });
+    } catch (e) {
+      reportException(window, e, filename);
+    } finally {
+      document._currentScript = null;
+    }
+  }
+}
+
+function getType(typeString) {
+  const lowercased = asciiLowercase(typeString);
+  // Cannot use whatwg-mimetype parsing because that strips whitespace. The spec demands a strict string comparison.
+  // That is, the type="" attribute is not really related to MIME types at all.
+  if (jsMIMETypes.has(lowercased)) {
+    return "classic";
+  }
+  if (lowercased === "module") {
+    return "module";
+  }
+  return null;
+}
+
+module.exports = {
+  implementation: HTMLScriptElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLSelectElement-impl.js b/lib/jsdom/living/nodes/HTMLSelectElement-impl.js
new file mode 100644
index 0000000..e6cf618
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLSelectElement-impl.js
@@ -0,0 +1,281 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+
+const idlUtils = require("../generated/utils.js");
+const ValidityState = require("../generated/ValidityState");
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { mixin } = require("../../utils");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const NODE_TYPE = require("../node-type");
+const HTMLCollection = require("../generated/HTMLCollection");
+const HTMLOptionsCollection = require("../generated/HTMLOptionsCollection");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { getLabelsForLabelable, formOwner, isDisabled } = require("../helpers/form-controls");
+const { parseNonNegativeInteger } = require("../helpers/strings");
+
+class HTMLSelectElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._options = HTMLOptionsCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => {
+        // Customized domSymbolTree.treeToArray() clone.
+        const array = [];
+        for (const child of domSymbolTree.childrenIterator(this)) {
+          if (child._localName === "option") {
+            array.push(child);
+          } else if (child._localName === "optgroup") {
+            for (const childOfGroup of domSymbolTree.childrenIterator(child)) {
+              if (childOfGroup._localName === "option") {
+                array.push(childOfGroup);
+              }
+            }
+          }
+        }
+        return array;
+      }
+    });
+    this._selectedOptions = null; // lazy
+
+    this._customValidityErrorMessage = "";
+
+    this._labels = null;
+  }
+
+  _formReset() {
+    for (const option of this.options) {
+      option._selectedness = option.hasAttributeNS(null, "selected");
+      option._dirtyness = false;
+    }
+    this._askedForAReset();
+  }
+
+  _askedForAReset() {
+    if (this.hasAttributeNS(null, "multiple")) {
+      return;
+    }
+
+    const selected = this.options.filter(opt => opt._selectedness);
+
+    const size = this._displaySize;
+    if (size === 1 && !selected.length) {
+      // select the first option that is not disabled
+      for (const option of this.options) {
+        let disabled = option.hasAttributeNS(null, "disabled");
+        const parentNode = domSymbolTree.parent(option);
+        if (parentNode &&
+          parentNode.nodeName.toUpperCase() === "OPTGROUP" &&
+          parentNode.hasAttributeNS(null, "disabled")) {
+          disabled = true;
+        }
+
+        if (!disabled) {
+          // (do not set dirty)
+          option._selectedness = true;
+          break;
+        }
+      }
+    } else if (selected.length >= 2) {
+      // select the last selected option
+      selected.forEach((option, index) => {
+        option._selectedness = index === selected.length - 1;
+      });
+    }
+  }
+
+  _descendantAdded(parent, child) {
+    if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+      this._askedForAReset();
+    }
+
+    super._descendantAdded.apply(this, arguments);
+  }
+
+  _descendantRemoved(parent, child) {
+    if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+      this._askedForAReset();
+    }
+
+    super._descendantRemoved.apply(this, arguments);
+  }
+
+  _attrModified(name) {
+    if (name === "multiple" || name === "size") {
+      this._askedForAReset();
+    }
+    super._attrModified.apply(this, arguments);
+  }
+
+  get _displaySize() {
+    if (this.hasAttributeNS(null, "size")) {
+      const size = parseNonNegativeInteger(this.getAttributeNS(null, "size"));
+      if (size !== null) {
+        return size;
+      }
+    }
+    return this.hasAttributeNS(null, "multiple") ? 4 : 1;
+  }
+
+  get _mutable() {
+    return !isDisabled(this);
+  }
+
+  get options() {
+    return this._options;
+  }
+
+  get selectedOptions() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => domSymbolTree.treeToArray(this, {
+        filter: node => node._localName === "option" && node._selectedness === true
+      })
+    });
+  }
+
+  get selectedIndex() {
+    for (let i = 0; i < this.options.length; i++) {
+      if (this.options.item(i)._selectedness) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  set selectedIndex(index) {
+    for (let i = 0; i < this.options.length; i++) {
+      this.options.item(i)._selectedness = false;
+    }
+
+    const selectedOption = this.options.item(index);
+    if (selectedOption) {
+      selectedOption._selectedness = true;
+      selectedOption._dirtyness = true;
+    }
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get value() {
+    for (const option of this.options) {
+      if (option._selectedness) {
+        return option.value;
+      }
+    }
+
+    return "";
+  }
+
+  set value(val) {
+    for (const option of this.options) {
+      if (option.value === val) {
+        option._selectedness = true;
+        option._dirtyness = true;
+      } else {
+        option._selectedness = false;
+      }
+    }
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get type() {
+    return this.hasAttributeNS(null, "multiple") ? "select-multiple" : "select-one";
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return this.options[idlUtils.supportedPropertyIndices];
+  }
+
+  get length() {
+    return this.options.length;
+  }
+
+  set length(value) {
+    this.options.length = value;
+  }
+
+  item(index) {
+    return this.options.item(index);
+  }
+
+  namedItem(name) {
+    return this.options.namedItem(name);
+  }
+
+  [idlUtils.indexedSetNew](index, value) {
+    return this.options[idlUtils.indexedSetNew](index, value);
+  }
+
+  [idlUtils.indexedSetExisting](index, value) {
+    return this.options[idlUtils.indexedSetExisting](index, value);
+  }
+
+  add(opt, before) {
+    this.options.add(opt, before);
+  }
+
+  remove(index) {
+    if (arguments.length > 0) {
+      index = conversions.long(index, {
+        context: "Failed to execute 'remove' on 'HTMLSelectElement': parameter 1"
+      });
+      this.options.remove(index);
+    } else {
+      super.remove();
+    }
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return this.hasAttributeNS(null, "readonly");
+  }
+
+  // Constraint validation: If the element has its required attribute specified,
+  // and either none of the option elements in the select element's list of options
+  // have their selectedness set to true, or the only option element in the select
+  // element's list of options with its selectedness set to true is the placeholder
+  // label option, then the element is suffering from being missing.
+  get validity() {
+    if (!this._validity) {
+      const state = {
+        valueMissing: () => {
+          if (!this.hasAttributeNS(null, "required")) {
+            return false;
+          }
+          const selectedOptionIndex = this.selectedIndex;
+          return selectedOptionIndex < 0 || (selectedOptionIndex === 0 && this._hasPlaceholderOption);
+        }
+      };
+
+      this._validity = ValidityState.createImpl(this._globalObject, [], {
+        element: this,
+        state
+      });
+    }
+    return this._validity;
+  }
+
+  // If a select element has a required attribute specified, does not have a multiple attribute
+  // specified, and has a display size of 1; and if the value of the first option element in the
+  // select element's list of options (if any) is the empty string, and that option element's parent
+  // node is the select element(and not an optgroup element), then that option is the select
+  // element's placeholder label option.
+  // https://html.spec.whatwg.org/multipage/form-elements.html#placeholder-label-option
+  get _hasPlaceholderOption() {
+    return this.hasAttributeNS(null, "required") && !this.hasAttributeNS(null, "multiple") &&
+      this._displaySize === 1 && this.options.length > 0 && this.options.item(0).value === "" &&
+      this.options.item(0).parentNode._localName !== "optgroup";
+  }
+}
+
+mixin(HTMLSelectElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLSelectElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLSlotElement-impl.js b/lib/jsdom/living/nodes/HTMLSlotElement-impl.js
new file mode 100644
index 0000000..a926993
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLSlotElement-impl.js
@@ -0,0 +1,59 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+const HTMLElement = require("../generated/HTMLElement");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const { nodeRoot } = require("../helpers/node");
+const { assignSlotableForTree, findFlattenedSlotables } = require("../helpers/shadow-dom");
+
+class HTMLSlotElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._assignedNodes = [];
+  }
+
+  // https://dom.spec.whatwg.org/#slot-name
+  get name() {
+    return this.getAttributeNS(null, "name") || "";
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    // https://dom.spec.whatwg.org/#slot-name
+    if (name === "name") {
+      if (value === oldValue) {
+        return;
+      }
+
+      if (value === null && oldValue === "") {
+        return;
+      }
+
+      if (value === "" && oldValue === null) {
+        return;
+      }
+
+      assignSlotableForTree(nodeRoot(this));
+    }
+  }
+
+  // https://html.spec.whatwg.org/#dom-slot-assignednodes
+  assignedNodes(options) {
+    if (!options || !options.flatten) {
+      return this._assignedNodes.map(idlUtils.wrapperForImpl);
+    }
+
+    return findFlattenedSlotables(this).map(idlUtils.wrapperForImpl);
+  }
+
+  // https://html.spec.whatwg.org/#dom-slot-assignedelements
+  assignedElements(options) {
+    return this.assignedNodes(options).filter(HTMLElement.is);
+  }
+}
+
+module.exports = {
+  implementation: HTMLSlotElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLSourceElement-impl.js b/lib/jsdom/living/nodes/HTMLSourceElement-impl.js
new file mode 100644
index 0000000..51af032
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLSourceElement-impl.js
@@ -0,0 +1,26 @@
+"use strict";
+const conversions = require("webidl-conversions");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { reflectURLAttribute } = require("../../utils");
+
+class HTMLSourceElementImpl extends HTMLElementImpl {
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+
+  get srcset() {
+    return conversions.USVString(this.getAttributeNS(null, "srcset"));
+  }
+
+  set srcset(value) {
+    this.setAttributeNS(null, "srcset", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLSourceElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLSpanElement-impl.js b/lib/jsdom/living/nodes/HTMLSpanElement-impl.js
new file mode 100644
index 0000000..9c00e6e
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLSpanElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLSpanElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLSpanElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLStyleElement-impl.js b/lib/jsdom/living/nodes/HTMLStyleElement-impl.js
new file mode 100644
index 0000000..7dcc6fb
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLStyleElement-impl.js
@@ -0,0 +1,74 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { removeStylesheet, createStylesheet } = require("../helpers/stylesheets");
+const { documentBaseURL } = require("../helpers/document-base-url");
+const { childTextContent } = require("../helpers/text");
+const { asciiCaseInsensitiveMatch } = require("../helpers/strings");
+
+class HTMLStyleElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.sheet = null;
+    this._isOnStackOfOpenElements = false;
+  }
+
+  _attach() {
+    super._attach();
+    if (!this._isOnStackOfOpenElements) {
+      this._updateAStyleBlock();
+    }
+  }
+
+  _detach() {
+    super._detach();
+    if (!this._isOnStackOfOpenElements) {
+      this._updateAStyleBlock();
+    }
+  }
+
+  _childTextContentChangeSteps() {
+    super._childTextContentChangeSteps();
+
+    // This guard is not required by the spec, but should be unobservable (since you can't run script during the middle
+    // of parsing a <style> element) and saves a bunch of unnecessary work.
+    if (!this._isOnStackOfOpenElements) {
+      this._updateAStyleBlock();
+    }
+  }
+
+  _poppedOffStackOfOpenElements() {
+    this._isOnStackOfOpenElements = false;
+    this._updateAStyleBlock();
+  }
+
+  _pushedOnStackOfOpenElements() {
+    this._isOnStackOfOpenElements = true;
+  }
+
+  _updateAStyleBlock() {
+    if (this.sheet) {
+      removeStylesheet(this.sheet, this);
+    }
+
+    // Browsing-context connected, per https://github.com/whatwg/html/issues/4547
+    if (!this.isConnected || !this._ownerDocument._defaultView) {
+      return;
+    }
+
+    const type = this.getAttributeNS(null, "type");
+    if (type !== null && type !== "" && !asciiCaseInsensitiveMatch(type, "text/css")) {
+      return;
+    }
+
+    // Not implemented: CSP
+
+    const content = childTextContent(this);
+    // Not implemented: a bunch of other state, e.g. title/media attributes
+    createStylesheet(content, this, documentBaseURL(this._ownerDocument));
+  }
+}
+
+module.exports = {
+  implementation: HTMLStyleElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTableCaptionElement-impl.js b/lib/jsdom/living/nodes/HTMLTableCaptionElement-impl.js
new file mode 100644
index 0000000..27ff421
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTableCaptionElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLTableCaptionElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLTableCaptionElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTableCellElement-impl.js b/lib/jsdom/living/nodes/HTMLTableCellElement-impl.js
new file mode 100644
index 0000000..6b6c13e
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTableCellElement-impl.js
@@ -0,0 +1,73 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const { asciiLowercase, parseNonNegativeInteger } = require("../helpers/strings");
+const { closest } = require("../helpers/traversal");
+
+function reflectedAttributeClampedToRange(attrValue, min, max, defaultValue = 0) {
+  if (attrValue === null) {
+    return defaultValue;
+  }
+  const parsed = parseNonNegativeInteger(attrValue);
+  if (parsed === null) {
+    return defaultValue;
+  }
+  if (parsed < min) {
+    return min;
+  }
+  if (parsed > max) {
+    return max;
+  }
+  return parsed;
+}
+
+class HTMLTableCellElementImpl extends HTMLElementImpl {
+  get colSpan() {
+    return reflectedAttributeClampedToRange(this.getAttributeNS(null, "colspan"), 1, 1000, 1);
+  }
+
+  set colSpan(V) {
+    this.setAttributeNS(null, "colspan", String(V));
+  }
+
+  get rowSpan() {
+    return reflectedAttributeClampedToRange(this.getAttributeNS(null, "rowspan"), 0, 65534, 1);
+  }
+
+  set rowSpan(V) {
+    this.setAttributeNS(null, "rowspan", String(V));
+  }
+
+  get cellIndex() {
+    const tr = closest(this, "tr");
+    if (tr === null) {
+      return -1;
+    }
+
+    return tr.cells.indexOf(this);
+  }
+
+  get scope() {
+    let value = this.getAttributeNS(null, "scope");
+    if (value === null) {
+      return "";
+    }
+
+    // Enumerated attribute is matched ASCII-case-insensitively.
+    value = asciiLowercase(value);
+    if (value === "row" || value === "col" || value === "rowgroup" || value === "colgroup") {
+      return value;
+    }
+
+    return "";
+  }
+
+  set scope(V) {
+    this.setAttributeNS(null, "scope", V);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableCellElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTableColElement-impl.js b/lib/jsdom/living/nodes/HTMLTableColElement-impl.js
new file mode 100644
index 0000000..d6cf3af
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTableColElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLTableColElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLTableColElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTableElement-impl.js b/lib/jsdom/living/nodes/HTMLTableElement-impl.js
new file mode 100644
index 0000000..a12e9f1
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTableElement-impl.js
@@ -0,0 +1,237 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { HTML_NS } = require("../helpers/namespaces");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { firstChildWithLocalName, childrenByLocalName } = require("../helpers/traversal");
+const HTMLCollection = require("../generated/HTMLCollection");
+const NODE_TYPE = require("../node-type");
+
+function tHeadInsertionPoint(table) {
+  const iterator = domSymbolTree.childrenIterator(table);
+  for (const child of iterator) {
+    if (child.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+      continue;
+    }
+
+    if (child._namespaceURI !== HTML_NS || (child._localName !== "caption" && child._localName !== "colgroup")) {
+      return child;
+    }
+  }
+
+  return null;
+}
+
+class HTMLTableElementImpl extends HTMLElementImpl {
+  get caption() {
+    return firstChildWithLocalName(this, "caption");
+  }
+
+  set caption(value) {
+    const currentCaption = this.caption;
+    if (currentCaption !== null) {
+      this.removeChild(currentCaption);
+    }
+
+    if (value !== null) {
+      const insertionPoint = this.firstChild;
+      this.insertBefore(value, insertionPoint);
+    }
+    return value;
+  }
+
+  get tHead() {
+    return firstChildWithLocalName(this, "thead");
+  }
+
+  set tHead(value) {
+    if (value !== null && value._localName !== "thead") {
+      throw DOMException.create(this._globalObject, [
+        "Cannot set a non-thead element as a table header",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    const currentHead = this.tHead;
+    if (currentHead !== null) {
+      this.removeChild(currentHead);
+    }
+
+    if (value !== null) {
+      const insertionPoint = tHeadInsertionPoint(this);
+      this.insertBefore(value, insertionPoint);
+    }
+  }
+
+  get tFoot() {
+    return firstChildWithLocalName(this, "tfoot");
+  }
+
+  set tFoot(value) {
+    if (value !== null && value._localName !== "tfoot") {
+      throw DOMException.create(this._globalObject, [
+        "Cannot set a non-tfoot element as a table footer",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    const currentFoot = this.tFoot;
+    if (currentFoot !== null) {
+      this.removeChild(currentFoot);
+    }
+
+    if (value !== null) {
+      this.appendChild(value);
+    }
+  }
+
+  get rows() {
+    if (!this._rows) {
+      this._rows = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => {
+          const headerRows = [];
+          const bodyRows = [];
+          const footerRows = [];
+
+          const iterator = domSymbolTree.childrenIterator(this);
+          for (const child of iterator) {
+            if (child.nodeType !== NODE_TYPE.ELEMENT_NODE || child._namespaceURI !== HTML_NS) {
+              continue;
+            }
+
+            if (child._localName === "thead") {
+              headerRows.push(...childrenByLocalName(child, "tr"));
+            } else if (child._localName === "tbody") {
+              bodyRows.push(...childrenByLocalName(child, "tr"));
+            } else if (child._localName === "tfoot") {
+              footerRows.push(...childrenByLocalName(child, "tr"));
+            } else if (child._localName === "tr") {
+              bodyRows.push(child);
+            }
+          }
+
+          return [...headerRows, ...bodyRows, ...footerRows];
+        }
+      });
+    }
+    return this._rows;
+  }
+
+  get tBodies() {
+    if (!this._tBodies) {
+      this._tBodies = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => childrenByLocalName(this, "tbody")
+      });
+    }
+    return this._tBodies;
+  }
+
+  createTBody() {
+    const el = this._ownerDocument.createElement("TBODY");
+
+    const tbodies = childrenByLocalName(this, "tbody");
+    const insertionPoint = tbodies[tbodies.length - 1];
+
+    if (insertionPoint) {
+      this.insertBefore(el, insertionPoint.nextSibling);
+    } else {
+      this.appendChild(el);
+    }
+    return el;
+  }
+
+  createTHead() {
+    let el = this.tHead;
+    if (!el) {
+      el = this.tHead = this._ownerDocument.createElement("THEAD");
+    }
+    return el;
+  }
+
+  deleteTHead() {
+    this.tHead = null;
+  }
+
+  createTFoot() {
+    let el = this.tFoot;
+    if (!el) {
+      el = this.tFoot = this._ownerDocument.createElement("TFOOT");
+    }
+    return el;
+  }
+
+  deleteTFoot() {
+    this.tFoot = null;
+  }
+
+  createCaption() {
+    let el = this.caption;
+    if (!el) {
+      el = this.caption = this._ownerDocument.createElement("CAPTION");
+    }
+    return el;
+  }
+
+  deleteCaption() {
+    const c = this.caption;
+    if (c) {
+      c.parentNode.removeChild(c);
+    }
+  }
+
+  insertRow(index) {
+    if (index < -1 || index > this.rows.length) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot insert a row at an index that is less than -1 or greater than the number of existing rows",
+        "IndexSizeError"
+      ]);
+    }
+
+    const tr = this._ownerDocument.createElement("tr");
+
+    if (this.rows.length === 0 && this.tBodies.length === 0) {
+      const tBody = this._ownerDocument.createElement("tbody");
+      tBody.appendChild(tr);
+      this.appendChild(tBody);
+    } else if (this.rows.length === 0) {
+      const tBody = this.tBodies.item(this.tBodies.length - 1);
+      tBody.appendChild(tr);
+    } else if (index === -1 || index === this.rows.length) {
+      const tSection = this.rows.item(this.rows.length - 1).parentNode;
+      tSection.appendChild(tr);
+    } else {
+      const beforeTR = this.rows.item(index);
+      const tSection = beforeTR.parentNode;
+      tSection.insertBefore(tr, beforeTR);
+    }
+
+    return tr;
+  }
+
+  deleteRow(index) {
+    const rowLength = this.rows.length;
+    if (index < -1 || index >= rowLength) {
+      throw DOMException.create(this._globalObject, [
+        `Cannot delete a row at index ${index}, where no row exists`,
+        "IndexSizeError"
+      ]);
+    }
+
+    if (index === -1) {
+      if (rowLength === 0) {
+        return;
+      }
+
+      index = rowLength - 1;
+    }
+
+    const tr = this.rows.item(index);
+    tr.parentNode.removeChild(tr);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTableRowElement-impl.js b/lib/jsdom/living/nodes/HTMLTableRowElement-impl.js
new file mode 100644
index 0000000..c65b52c
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTableRowElement-impl.js
@@ -0,0 +1,88 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const HTMLCollection = require("../generated/HTMLCollection");
+const { HTML_NS } = require("../helpers/namespaces");
+const { childrenByLocalNames } = require("../helpers/traversal");
+const { domSymbolTree } = require("../helpers/internal-constants");
+
+const cellLocalNames = new Set(["td", "th"]);
+
+class HTMLTableRowElementImpl extends HTMLElementImpl {
+  get cells() {
+    if (!this._cells) {
+      this._cells = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => childrenByLocalNames(this, cellLocalNames)
+      });
+    }
+    return this._cells;
+  }
+
+  get rowIndex() {
+    const parent = this.parentElement;
+    if (parent === null || parent.namespaceURI !== HTML_NS) {
+      return -1;
+    }
+
+    let tableElement = parent;
+    if (parent.localName === "thead" || parent.localName === "tbody" || parent.localName === "tfoot") {
+      tableElement = parent.parentElement;
+    }
+    if (tableElement === null || tableElement.namespaceURI !== HTML_NS || tableElement.localName !== "table") {
+      return -1;
+    }
+
+    return tableElement.rows.indexOf(this);
+  }
+
+  get sectionRowIndex() {
+    const parent = domSymbolTree.parent(this);
+    if (parent === null) {
+      return -1;
+    }
+
+    const { rows } = parent;
+    if (!rows) {
+      return -1;
+    }
+
+    return rows.indexOf(this);
+  }
+
+  insertCell(index) {
+    const td = this._ownerDocument.createElement("TD");
+    const { cells } = this;
+    if (index < -1 || index > cells.length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    if (index === -1 || index === cells.length) {
+      this._append(td);
+    } else {
+      const ref = cells.item(index);
+      this._insert(td, ref);
+    }
+    return td;
+  }
+
+  deleteCell(index) {
+    const { cells } = this;
+    if (index < -1 || index >= cells.length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    if (index === -1) {
+      if (cells.length === 0) {
+        return;
+      }
+
+      index = cells.length - 1;
+    }
+    const td = cells.item(index);
+    this._remove(td);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableRowElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTableSectionElement-impl.js b/lib/jsdom/living/nodes/HTMLTableSectionElement-impl.js
new file mode 100644
index 0000000..3cf767b
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTableSectionElement-impl.js
@@ -0,0 +1,61 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { childrenByLocalName } = require("../helpers/traversal");
+const HTMLCollection = require("../generated/HTMLCollection");
+const DOMException = require("domexception/webidl2js-wrapper");
+
+class HTMLTableSectionElementImpl extends HTMLElementImpl {
+  get rows() {
+    if (!this._rows) {
+      this._rows = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => childrenByLocalName(this, "tr")
+      });
+    }
+    return this._rows;
+  }
+
+  insertRow(index) {
+    if (index < -1 || index > this.rows.length) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot insert a row at an index that is less than -1 or greater than the number of existing rows",
+        "IndexSizeError"
+      ]);
+    }
+
+    const tr = this._ownerDocument.createElement("tr");
+
+    if (index === -1 || index === this.rows.length) {
+      this._append(tr);
+    } else {
+      const beforeTR = this.rows.item(index);
+      this._insert(tr, beforeTR);
+    }
+
+    return tr;
+  }
+
+  deleteRow(index) {
+    if (index < -1 || index >= this.rows.length) {
+      throw DOMException.create(this._globalObject, [
+        `Cannot delete a row at index ${index}, where no row exists`,
+        "IndexSizeError"
+      ]);
+    }
+
+    if (index === -1) {
+      if (this.rows.length > 0) {
+        const tr = this.rows.item(this.rows.length - 1);
+        this._remove(tr);
+      }
+    } else {
+      const tr = this.rows.item(index);
+      this._remove(tr);
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableSectionElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTemplateElement-impl.js b/lib/jsdom/living/nodes/HTMLTemplateElement-impl.js
new file mode 100644
index 0000000..b0a2405
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTemplateElement-impl.js
@@ -0,0 +1,67 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const Document = require("../generated/Document");
+const DocumentFragment = require("../generated/DocumentFragment");
+
+const { cloningSteps, domSymbolTree } = require("../helpers/internal-constants");
+const { clone } = require("../node");
+
+class HTMLTemplateElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const doc = this._appropriateTemplateContentsOwnerDocument(this._ownerDocument);
+    this._templateContents = DocumentFragment.createImpl(this._globalObject, [], {
+      ownerDocument: doc,
+      host: this
+    });
+  }
+
+  // https://html.spec.whatwg.org/multipage/scripting.html#appropriate-template-contents-owner-document
+  _appropriateTemplateContentsOwnerDocument(doc) {
+    if (!doc._isInertTemplateDocument) {
+      if (doc._associatedInertTemplateDocument === undefined) {
+        const newDoc = Document.createImpl(this._globalObject, [], {
+          options: {
+            parsingMode: doc._parsingMode,
+            encoding: doc._encoding
+          }
+        });
+        newDoc._isInertTemplateDocument = true;
+
+        doc._associatedInertTemplateDocument = newDoc;
+      }
+
+      doc = doc._associatedInertTemplateDocument;
+    }
+
+    return doc;
+  }
+
+  // https://html.spec.whatwg.org/multipage/scripting.html#template-adopting-steps
+  _adoptingSteps() {
+    const doc = this._appropriateTemplateContentsOwnerDocument(this._ownerDocument);
+    doc._adoptNode(this._templateContents);
+  }
+
+  get content() {
+    return this._templateContents;
+  }
+
+  [cloningSteps](copy, node, document, cloneChildren) {
+    if (!cloneChildren) {
+      return;
+    }
+
+    for (const child of domSymbolTree.childrenIterator(node._templateContents)) {
+      const childCopy = clone(child, copy._templateContents._ownerDocument, true);
+      copy._templateContents.appendChild(childCopy);
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLTemplateElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTextAreaElement-impl.js b/lib/jsdom/living/nodes/HTMLTextAreaElement-impl.js
new file mode 100644
index 0000000..7202e86
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTextAreaElement-impl.js
@@ -0,0 +1,244 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const ValidityState = require("../generated/ValidityState");
+const { mixin } = require("../../utils");
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const { cloningSteps } = require("../helpers/internal-constants");
+const { isDisabled, normalizeToCRLF, getLabelsForLabelable, formOwner } = require("../helpers/form-controls");
+const { childTextContent } = require("../helpers/text");
+const { fireAnEvent } = require("../helpers/events");
+
+class HTMLTextAreaElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._selectionStart = this._selectionEnd = 0;
+    this._selectionDirection = "none";
+    this._rawValue = "";
+    this._dirtyValue = false;
+
+    this._customValidityErrorMessage = "";
+
+    this._labels = null;
+  }
+
+  _formReset() {
+    this._rawValue = childTextContent(this);
+    this._dirtyValue = false;
+  }
+
+  _getAPIValue() {
+    return this._rawValue.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#textarea-wrapping-transformation
+  _getValue() {
+    // Hard-wrapping omitted, for now.
+    return normalizeToCRLF(this._rawValue);
+  }
+
+  _childTextContentChangeSteps() {
+    super._childTextContentChangeSteps();
+
+    if (this._dirtyValue === false) {
+      this._rawValue = childTextContent(this);
+    }
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get defaultValue() {
+    return childTextContent(this);
+  }
+
+  set defaultValue(val) {
+    this.textContent = val;
+  }
+
+  get value() {
+    return this._getAPIValue();
+  }
+
+  set value(val) {
+    // https://html.spec.whatwg.org/multipage/form-elements.html#dom-textarea-value
+    const oldAPIValue = this._getAPIValue();
+    this._rawValue = val;
+    this._dirtyValue = true;
+
+    if (oldAPIValue !== this._getAPIValue()) {
+      this._selectionStart = this._selectionEnd = this._getValueLength();
+      this._selectionDirection = "none";
+    }
+  }
+
+  get textLength() {
+    return this.value.length; // code unit length (16 bit)
+  }
+
+  get type() {
+    return "textarea";
+  }
+
+  _dispatchSelectEvent() {
+    fireAnEvent("select", this, undefined, { bubbles: true, cancelable: true });
+  }
+
+  _getValueLength() {
+    return typeof this.value === "string" ? this.value.length : 0;
+  }
+
+  select() {
+    this._selectionStart = 0;
+    this._selectionEnd = this._getValueLength();
+    this._selectionDirection = "none";
+    this._dispatchSelectEvent();
+  }
+
+  get selectionStart() {
+    return this._selectionStart;
+  }
+
+  set selectionStart(start) {
+    this.setSelectionRange(start, Math.max(start, this._selectionEnd), this._selectionDirection);
+  }
+
+  get selectionEnd() {
+    return this._selectionEnd;
+  }
+
+  set selectionEnd(end) {
+    this.setSelectionRange(this._selectionStart, end, this._selectionDirection);
+  }
+
+  get selectionDirection() {
+    return this._selectionDirection;
+  }
+
+  set selectionDirection(dir) {
+    this.setSelectionRange(this._selectionStart, this._selectionEnd, dir);
+  }
+
+  setSelectionRange(start, end, dir) {
+    this._selectionEnd = Math.min(end, this._getValueLength());
+    this._selectionStart = Math.min(start, this._selectionEnd);
+    this._selectionDirection = dir === "forward" || dir === "backward" ? dir : "none";
+    this._dispatchSelectEvent();
+  }
+
+  setRangeText(repl, start, end, selectionMode = "preserve") {
+    if (arguments.length < 2) {
+      start = this._selectionStart;
+      end = this._selectionEnd;
+    } else if (start > end) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    start = Math.min(start, this._getValueLength());
+    end = Math.min(end, this._getValueLength());
+
+    const val = this.value;
+    let selStart = this._selectionStart;
+    let selEnd = this._selectionEnd;
+
+    this.value = val.slice(0, start) + repl + val.slice(end);
+
+    const newEnd = start + this.value.length;
+
+    if (selectionMode === "select") {
+      this.setSelectionRange(start, newEnd);
+    } else if (selectionMode === "start") {
+      this.setSelectionRange(start, start);
+    } else if (selectionMode === "end") {
+      this.setSelectionRange(newEnd, newEnd);
+    } else { // preserve
+      const delta = repl.length - (end - start);
+
+      if (selStart > end) {
+        selStart += delta;
+      } else if (selStart > start) {
+        selStart = start;
+      }
+
+      if (selEnd > end) {
+        selEnd += delta;
+      } else if (selEnd > start) {
+        selEnd = newEnd;
+      }
+
+      this.setSelectionRange(selStart, selEnd);
+    }
+  }
+
+  get cols() {
+    if (!this.hasAttributeNS(null, "cols")) {
+      return 20;
+    }
+    return parseInt(this.getAttributeNS(null, "cols"));
+  }
+
+  set cols(value) {
+    if (value <= 0) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    this.setAttributeNS(null, "cols", String(value));
+  }
+
+  get rows() {
+    if (!this.hasAttributeNS(null, "rows")) {
+      return 2;
+    }
+    return parseInt(this.getAttributeNS(null, "rows"));
+  }
+
+  set rows(value) {
+    if (value <= 0) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    this.setAttributeNS(null, "rows", String(value));
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return this.hasAttributeNS(null, "readonly");
+  }
+
+  get _mutable() {
+    return !isDisabled(this) && !this.hasAttributeNS(null, "readonly");
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-elements.html#attr-textarea-required
+  get validity() {
+    if (!this._validity) {
+      const state = {
+        valueMissing: () => this.hasAttributeNS(null, "required") && this._mutable && this.value === ""
+      };
+
+      this._validity = ValidityState.createImpl(this._globalObject, [], {
+        element: this,
+        state
+      });
+    }
+    return this._validity;
+  }
+
+  [cloningSteps](copy, node) {
+    copy._dirtyValue = node._dirtyValue;
+    copy._rawValue = node._rawValue;
+  }
+}
+
+mixin(HTMLTextAreaElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLTextAreaElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTimeElement-impl.js b/lib/jsdom/living/nodes/HTMLTimeElement-impl.js
new file mode 100644
index 0000000..0378649
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTimeElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLTimeElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLTimeElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTitleElement-impl.js b/lib/jsdom/living/nodes/HTMLTitleElement-impl.js
new file mode 100644
index 0000000..fad736c
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTitleElement-impl.js
@@ -0,0 +1,18 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { childTextContent } = require("../helpers/text");
+
+class HTMLTitleElementImpl extends HTMLElementImpl {
+  get text() {
+    return childTextContent(this);
+  }
+
+  set text(value) {
+    this.textContent = value;
+  }
+}
+
+module.exports = {
+  implementation: HTMLTitleElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLTrackElement-impl.js b/lib/jsdom/living/nodes/HTMLTrackElement-impl.js
new file mode 100644
index 0000000..4e91ba4
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLTrackElement-impl.js
@@ -0,0 +1,21 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { reflectURLAttribute } = require("../../utils");
+
+class HTMLTrackElementImpl extends HTMLElementImpl {
+  get readyState() {
+    return 0;
+  }
+
+  get src() {
+    return reflectURLAttribute(this, "src");
+  }
+  set src(value) {
+    this.setAttributeNS(null, "src", value);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTrackElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLUListElement-impl.js b/lib/jsdom/living/nodes/HTMLUListElement-impl.js
new file mode 100644
index 0000000..ed22ec0
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLUListElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLUListElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLUListElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLUnknownElement-impl.js b/lib/jsdom/living/nodes/HTMLUnknownElement-impl.js
new file mode 100644
index 0000000..89b2b2b
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLUnknownElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLUnknownElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLUnknownElementImpl
+};
diff --git a/lib/jsdom/living/nodes/HTMLVideoElement-impl.js b/lib/jsdom/living/nodes/HTMLVideoElement-impl.js
new file mode 100644
index 0000000..3705099
--- /dev/null
+++ b/lib/jsdom/living/nodes/HTMLVideoElement-impl.js
@@ -0,0 +1,26 @@
+"use strict";
+
+const HTMLMediaElementImpl = require("./HTMLMediaElement-impl").implementation;
+const { reflectURLAttribute } = require("../../utils");
+
+class HTMLVideoElementImpl extends HTMLMediaElementImpl {
+  get poster() {
+    return reflectURLAttribute(this, "poster");
+  }
+
+  set poster(value) {
+    this.setAttributeNS(null, "poster", value);
+  }
+
+  get videoWidth() {
+    return 0;
+  }
+
+  get videoHeight() {
+    return 0;
+  }
+}
+
+module.exports = {
+  implementation: HTMLVideoElementImpl
+};
diff --git a/lib/jsdom/living/nodes/LinkStyle-impl.js b/lib/jsdom/living/nodes/LinkStyle-impl.js
new file mode 100644
index 0000000..7a6c5d8
--- /dev/null
+++ b/lib/jsdom/living/nodes/LinkStyle-impl.js
@@ -0,0 +1,2 @@
+"use strict";
+module.exports = class LinkStyleImpl {};
diff --git a/lib/jsdom/living/nodes/Node-impl.js b/lib/jsdom/living/nodes/Node-impl.js
new file mode 100644
index 0000000..11ce11b
--- /dev/null
+++ b/lib/jsdom/living/nodes/Node-impl.js
@@ -0,0 +1,1165 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+const { simultaneousIterators } = require("../../utils");
+const NODE_TYPE = require("../node-type");
+const NODE_DOCUMENT_POSITION = require("../node-document-position");
+const { clone, locateNamespacePrefix, locateNamespace } = require("../node");
+const { setAnExistingAttributeValue } = require("../attributes");
+
+const NodeList = require("../generated/NodeList");
+
+const { nodeRoot, nodeLength } = require("../helpers/node");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { documentBaseURLSerialized } = require("../helpers/document-base-url");
+const { queueTreeMutationRecord } = require("../helpers/mutation-observers");
+const { enqueueCECallbackReaction, tryUpgradeElement } = require("../helpers/custom-elements");
+const {
+  isShadowRoot, shadowIncludingRoot, assignSlot, assignSlotableForTree, assignSlotable, signalSlotChange, isSlot,
+  shadowIncludingInclusiveDescendantsIterator, shadowIncludingDescendantsIterator
+} = require("../helpers/shadow-dom");
+
+function isObsoleteNodeType(node) {
+  return node.nodeType === NODE_TYPE.ENTITY_NODE ||
+    node.nodeType === NODE_TYPE.ENTITY_REFERENCE_NODE ||
+    node.nodeType === NODE_TYPE.NOTATION_NODE ||
+    node.nodeType === NODE_TYPE.CDATA_SECTION_NODE;
+}
+
+function nodeEquals(a, b) {
+  if (a.nodeType !== b.nodeType) {
+    return false;
+  }
+
+  switch (a.nodeType) {
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+      if (a.name !== b.name || a.publicId !== b.publicId ||
+          a.systemId !== b.systemId) {
+        return false;
+      }
+      break;
+    case NODE_TYPE.ELEMENT_NODE:
+      if (a._namespaceURI !== b._namespaceURI || a._prefix !== b._prefix || a._localName !== b._localName ||
+          a._attributes.length !== b._attributes.length) {
+        return false;
+      }
+      break;
+    case NODE_TYPE.ATTRIBUTE_NODE:
+      if (a._namespace !== b._namespace || a._localName !== b._localName || a._value !== b._value) {
+        return false;
+      }
+      break;
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      if (a._target !== b._target || a._data !== b._data) {
+        return false;
+      }
+      break;
+    case NODE_TYPE.TEXT_NODE:
+    case NODE_TYPE.COMMENT_NODE:
+      if (a._data !== b._data) {
+        return false;
+      }
+      break;
+  }
+
+  if (a.nodeType === NODE_TYPE.ELEMENT_NODE && !attributeListsEqual(a, b)) {
+    return false;
+  }
+
+  for (const nodes of simultaneousIterators(domSymbolTree.childrenIterator(a), domSymbolTree.childrenIterator(b))) {
+    if (!nodes[0] || !nodes[1]) {
+      // mismatch in the amount of childNodes
+      return false;
+    }
+
+    if (!nodeEquals(nodes[0], nodes[1])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Needed by https://dom.spec.whatwg.org/#concept-node-equals
+function attributeListsEqual(elementA, elementB) {
+  const listA = elementA._attributeList;
+  const listB = elementB._attributeList;
+
+  const lengthA = listA.length;
+  const lengthB = listB.length;
+
+  if (lengthA !== lengthB) {
+    return false;
+  }
+
+  for (let i = 0; i < lengthA; ++i) {
+    const attrA = listA[i];
+
+    if (!listB.some(attrB => nodeEquals(attrA, attrB))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// https://dom.spec.whatwg.org/#concept-tree-host-including-inclusive-ancestor
+function isHostInclusiveAncestor(nodeImplA, nodeImplB) {
+  for (const ancestor of domSymbolTree.ancestorsIterator(nodeImplB)) {
+    if (ancestor === nodeImplA) {
+      return true;
+    }
+  }
+
+  const rootImplB = nodeRoot(nodeImplB);
+  if (rootImplB._host) {
+    return isHostInclusiveAncestor(nodeImplA, rootImplB._host);
+  }
+
+  return false;
+}
+
+class NodeImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    domSymbolTree.initialize(this);
+
+    this._ownerDocument = privateData.ownerDocument;
+
+    this._childNodesList = null;
+    this._childrenList = null;
+    this._version = 0;
+    this._memoizedQueries = {};
+    this._registeredObserverList = [];
+    this._referencedRanges = new Set();
+  }
+
+  _getTheParent() {
+    if (this._assignedSlot) {
+      return this._assignedSlot;
+    }
+
+    return domSymbolTree.parent(this);
+  }
+
+  get parentNode() {
+    return domSymbolTree.parent(this);
+  }
+
+  getRootNode(options) {
+    return options.composed ? shadowIncludingRoot(this) : nodeRoot(this);
+  }
+
+  get nodeName() {
+    switch (this.nodeType) {
+      case NODE_TYPE.ELEMENT_NODE:
+        return this.tagName;
+      case NODE_TYPE.ATTRIBUTE_NODE:
+        return this._qualifiedName;
+      case NODE_TYPE.TEXT_NODE:
+        return "#text";
+      case NODE_TYPE.CDATA_SECTION_NODE:
+        return "#cdata-section";
+      case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+        return this.target;
+      case NODE_TYPE.COMMENT_NODE:
+        return "#comment";
+      case NODE_TYPE.DOCUMENT_NODE:
+        return "#document";
+      case NODE_TYPE.DOCUMENT_TYPE_NODE:
+        return this.name;
+      case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+        return "#document-fragment";
+    }
+
+    // should never happen
+    return null;
+  }
+
+  get firstChild() {
+    return domSymbolTree.firstChild(this);
+  }
+
+  // https://dom.spec.whatwg.org/#connected
+  // https://dom.spec.whatwg.org/#dom-node-isconnected
+  get isConnected() {
+    const root = shadowIncludingRoot(this);
+    return root && root.nodeType === NODE_TYPE.DOCUMENT_NODE;
+  }
+
+  get ownerDocument() {
+    return this.nodeType === NODE_TYPE.DOCUMENT_NODE ? null : this._ownerDocument;
+  }
+
+  get lastChild() {
+    return domSymbolTree.lastChild(this);
+  }
+
+  get childNodes() {
+    if (!this._childNodesList) {
+      this._childNodesList = NodeList.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => domSymbolTree.childrenToArray(this)
+      });
+    } else {
+      this._childNodesList._update();
+    }
+
+    return this._childNodesList;
+  }
+
+  get nextSibling() {
+    return domSymbolTree.nextSibling(this);
+  }
+
+  get previousSibling() {
+    return domSymbolTree.previousSibling(this);
+  }
+
+  _modified() {
+    this._version++;
+    for (const ancestor of domSymbolTree.ancestorsIterator(this)) {
+      ancestor._version++;
+    }
+
+    if (this._childrenList) {
+      this._childrenList._update();
+    }
+    if (this._childNodesList) {
+      this._childNodesList._update();
+    }
+    this._clearMemoizedQueries();
+  }
+
+  _childTextContentChangeSteps() {
+    // Default: do nothing
+  }
+
+  _clearMemoizedQueries() {
+    this._memoizedQueries = {};
+    const myParent = domSymbolTree.parent(this);
+    if (myParent) {
+      myParent._clearMemoizedQueries();
+    }
+  }
+
+  _descendantRemoved(parent, child) {
+    const myParent = domSymbolTree.parent(this);
+    if (myParent) {
+      myParent._descendantRemoved(parent, child);
+    }
+  }
+
+  _descendantAdded(parent, child) {
+    const myParent = domSymbolTree.parent(this);
+    if (myParent) {
+      myParent._descendantAdded(parent, child);
+    }
+  }
+
+  _attach() {
+    this._attached = true;
+
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child._attach) {
+        child._attach();
+      }
+    }
+  }
+
+  _detach() {
+    this._attached = false;
+
+    if (this._ownerDocument && this._ownerDocument._lastFocusedElement === this) {
+      this._ownerDocument._lastFocusedElement = null;
+    }
+
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child._detach) {
+        child._detach();
+      }
+    }
+  }
+
+  hasChildNodes() {
+    return domSymbolTree.hasChildren(this);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-normalize
+  normalize() {
+    // It is important to use a treeToArray instead of a treeToIterator here, because the
+    // treeToIterator doesn't support tree mutation in the middle of the traversal.
+    for (const node of domSymbolTree.treeToArray(this)) {
+      const parentNode = domSymbolTree.parent(node);
+      if (parentNode === null || node.nodeType !== NODE_TYPE.TEXT_NODE) {
+        continue;
+      }
+
+      let length = nodeLength(node);
+
+      if (length === 0) {
+        parentNode._remove(node);
+        continue;
+      }
+
+      const continuousExclusiveTextNodes = [];
+
+      for (const currentNode of domSymbolTree.previousSiblingsIterator(node)) {
+        if (currentNode.nodeType !== NODE_TYPE.TEXT_NODE) {
+          break;
+        }
+
+        continuousExclusiveTextNodes.unshift(currentNode);
+      }
+      for (const currentNode of domSymbolTree.nextSiblingsIterator(node)) {
+        if (currentNode.nodeType !== NODE_TYPE.TEXT_NODE) {
+          break;
+        }
+
+        continuousExclusiveTextNodes.push(currentNode);
+      }
+
+      const data = continuousExclusiveTextNodes.reduce((d, n) => d + n._data, "");
+      node.replaceData(length, 0, data);
+
+      let currentNode = domSymbolTree.nextSibling(node);
+      while (currentNode && currentNode.nodeType !== NODE_TYPE.TEXT_NODE) {
+        const currentNodeParent = domSymbolTree.parent(currentNode);
+        const currentNodeIndex = domSymbolTree.index(currentNode);
+
+        for (const range of node._referencedRanges) {
+          const { _start, _end } = range;
+
+          if (_start.node === currentNode) {
+            range._setLiveRangeStart(node, _start.offset + length);
+          }
+          if (_end.node === currentNode) {
+            range._setLiveRangeEnd(node, _end.offset + length);
+          }
+          if (_start.node === currentNodeParent && _start.offset === currentNodeIndex) {
+            range._setLiveRangeStart(node, length);
+          }
+          if (_end.node === currentNodeParent && _end.offset === currentNodeIndex) {
+            range._setLiveRangeStart(node, length);
+          }
+        }
+
+        length += nodeLength(currentNode);
+        currentNode = domSymbolTree.nextSibling(currentNode);
+      }
+
+      for (const continuousExclusiveTextNode of continuousExclusiveTextNodes) {
+        parentNode._remove(continuousExclusiveTextNode);
+      }
+    }
+  }
+
+  get parentElement() {
+    const parentNode = domSymbolTree.parent(this);
+    return parentNode !== null && parentNode.nodeType === NODE_TYPE.ELEMENT_NODE ? parentNode : null;
+  }
+
+  get baseURI() {
+    return documentBaseURLSerialized(this._ownerDocument);
+  }
+
+  compareDocumentPosition(other) {
+    // Let node1 be other and node2 be the context object.
+    let node1 = other;
+    let node2 = this;
+
+    if (isObsoleteNodeType(node2) || isObsoleteNodeType(node1)) {
+      throw new Error("Obsolete node type");
+    }
+
+    let attr1 = null;
+    let attr2 = null;
+
+    if (node1.nodeType === NODE_TYPE.ATTRIBUTE_NODE) {
+      attr1 = node1;
+      node1 = attr1._element;
+    }
+
+    if (node2.nodeType === NODE_TYPE.ATTRIBUTE_NODE) {
+      attr2 = node2;
+      node2 = attr2._element;
+
+      if (attr1 !== null && node1 !== null && node2 === node1) {
+        for (const attr of node2._attributeList) {
+          if (nodeEquals(attr, attr1)) {
+            return NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC |
+              NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_PRECEDING;
+          }
+
+          if (nodeEquals(attr, attr2)) {
+            return NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC |
+              NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_FOLLOWING;
+          }
+        }
+      }
+    }
+
+    const result = domSymbolTree.compareTreePosition(node2, node1);
+
+    // “If other and reference are not in the same tree, return the result of adding DOCUMENT_POSITION_DISCONNECTED,
+    //  DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, and either DOCUMENT_POSITION_PRECEDING or
+    // DOCUMENT_POSITION_FOLLOWING, with the constraint that this is to be consistent, together.”
+    if (result === NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_DISCONNECTED) {
+      // symbol-tree does not add these bits required by the spec:
+      return NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_DISCONNECTED |
+        NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC |
+        NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_FOLLOWING;
+    }
+
+    return result;
+  }
+
+  lookupPrefix(namespace) {
+    if (namespace === null || namespace === "") {
+      return null;
+    }
+
+    switch (this.nodeType) {
+      case NODE_TYPE.ELEMENT_NODE: {
+        return locateNamespacePrefix(this, namespace);
+      }
+      case NODE_TYPE.DOCUMENT_NODE: {
+        return this.documentElement !== null ? locateNamespacePrefix(this.documentElement, namespace) : null;
+      }
+      case NODE_TYPE.DOCUMENT_TYPE_NODE:
+      case NODE_TYPE.DOCUMENT_FRAGMENT_NODE: {
+        return null;
+      }
+      case NODE_TYPE.ATTRIBUTE_NODE: {
+        return this._element !== null ? locateNamespacePrefix(this._element, namespace) : null;
+      }
+      default: {
+        return this.parentElement !== null ? locateNamespacePrefix(this.parentElement, namespace) : null;
+      }
+    }
+  }
+
+  lookupNamespaceURI(prefix) {
+    if (prefix === "") {
+      prefix = null;
+    }
+
+    return locateNamespace(this, prefix);
+  }
+
+  isDefaultNamespace(namespace) {
+    if (namespace === "") {
+      namespace = null;
+    }
+
+    const defaultNamespace = locateNamespace(this, null);
+    return defaultNamespace === namespace;
+  }
+
+  contains(other) {
+    if (other === null) {
+      return false;
+    } else if (this === other) {
+      return true;
+    }
+    return Boolean(this.compareDocumentPosition(other) & NODE_DOCUMENT_POSITION.DOCUMENT_POSITION_CONTAINED_BY);
+  }
+
+  isEqualNode(node) {
+    if (node === null) {
+      return false;
+    }
+
+    // Fast-path, not in the spec
+    if (this === node) {
+      return true;
+    }
+
+    return nodeEquals(this, node);
+  }
+
+  isSameNode(node) {
+    if (this === node) {
+      return true;
+    }
+
+    return false;
+  }
+
+  cloneNode(deep) {
+    if (isShadowRoot(this)) {
+      throw DOMException.create(this._globalObject, ["ShadowRoot nodes are not clonable.", "NotSupportedError"]);
+    }
+
+    deep = Boolean(deep);
+
+    return clone(this, undefined, deep);
+  }
+
+  get nodeValue() {
+    switch (this.nodeType) {
+      case NODE_TYPE.ATTRIBUTE_NODE: {
+        return this._value;
+      }
+      case NODE_TYPE.TEXT_NODE:
+      case NODE_TYPE.CDATA_SECTION_NODE: // CDATASection is a subclass of Text
+      case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      case NODE_TYPE.COMMENT_NODE: {
+        return this._data;
+      }
+      default: {
+        return null;
+      }
+    }
+  }
+
+  set nodeValue(value) {
+    if (value === null) {
+      value = "";
+    }
+
+    switch (this.nodeType) {
+      case NODE_TYPE.ATTRIBUTE_NODE: {
+        setAnExistingAttributeValue(this, value);
+        break;
+      }
+      case NODE_TYPE.TEXT_NODE:
+      case NODE_TYPE.CDATA_SECTION_NODE: // CDATASection is a subclass of Text
+      case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      case NODE_TYPE.COMMENT_NODE: {
+        this.replaceData(0, this.length, value);
+        break;
+      }
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-textcontent
+  get textContent() {
+    switch (this.nodeType) {
+      case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+      case NODE_TYPE.ELEMENT_NODE: {
+        let text = "";
+        for (const child of domSymbolTree.treeIterator(this)) {
+          if (child.nodeType === NODE_TYPE.TEXT_NODE || child.nodeType === NODE_TYPE.CDATA_SECTION_NODE) {
+            text += child.nodeValue;
+          }
+        }
+        return text;
+      }
+
+      case NODE_TYPE.ATTRIBUTE_NODE: {
+        return this._value;
+      }
+
+      case NODE_TYPE.TEXT_NODE:
+      case NODE_TYPE.CDATA_SECTION_NODE: // CDATASection is a subclass of Text
+      case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      case NODE_TYPE.COMMENT_NODE: {
+        return this._data;
+      }
+
+      default: {
+        return null;
+      }
+    }
+  }
+  set textContent(value) {
+    if (value === null) {
+      value = "";
+    }
+
+    switch (this.nodeType) {
+      case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+      case NODE_TYPE.ELEMENT_NODE: {
+        // https://dom.spec.whatwg.org/#string-replace-all
+        let nodeImpl = null;
+
+        if (value !== "") {
+          nodeImpl = this._ownerDocument.createTextNode(value);
+        }
+
+        this._replaceAll(nodeImpl);
+        break;
+      }
+
+      case NODE_TYPE.ATTRIBUTE_NODE: {
+        setAnExistingAttributeValue(this, value);
+        break;
+      }
+
+      case NODE_TYPE.TEXT_NODE:
+      case NODE_TYPE.CDATA_SECTION_NODE: // CDATASection is a subclass of Text
+      case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      case NODE_TYPE.COMMENT_NODE: {
+        this.replaceData(0, this.length, value);
+        break;
+      }
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-insertbefore
+  insertBefore(nodeImpl, childImpl) {
+    return this._preInsert(nodeImpl, childImpl);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-appendchild
+  appendChild(nodeImpl) {
+    return this._append(nodeImpl);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-replacechild
+  replaceChild(nodeImpl, childImpl) {
+    return this._replace(nodeImpl, childImpl);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-removechild
+  removeChild(oldChildImpl) {
+    return this._preRemove(oldChildImpl);
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
+  _preInsertValidity(nodeImpl, childImpl) {
+    const { nodeType, nodeName } = nodeImpl;
+    const { nodeType: parentType, nodeName: parentName } = this;
+
+    if (
+      parentType !== NODE_TYPE.DOCUMENT_NODE &&
+      parentType !== NODE_TYPE.DOCUMENT_FRAGMENT_NODE &&
+      parentType !== NODE_TYPE.ELEMENT_NODE
+    ) {
+      throw DOMException.create(this._globalObject, [
+        `Node can't be inserted in a ${parentName} parent.`,
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (isHostInclusiveAncestor(nodeImpl, this)) {
+      throw DOMException.create(this._globalObject, [
+        "The operation would yield an incorrect node tree.",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (childImpl && domSymbolTree.parent(childImpl) !== this) {
+      throw DOMException.create(this._globalObject, [
+        "The child can not be found in the parent.",
+        "NotFoundError"
+      ]);
+    }
+
+    if (
+      nodeType !== NODE_TYPE.DOCUMENT_FRAGMENT_NODE &&
+      nodeType !== NODE_TYPE.DOCUMENT_TYPE_NODE &&
+      nodeType !== NODE_TYPE.ELEMENT_NODE &&
+      nodeType !== NODE_TYPE.TEXT_NODE &&
+      nodeType !== NODE_TYPE.CDATA_SECTION_NODE && // CData section extends from Text
+      nodeType !== NODE_TYPE.PROCESSING_INSTRUCTION_NODE &&
+      nodeType !== NODE_TYPE.COMMENT_NODE
+    ) {
+      throw DOMException.create(this._globalObject, [
+        `${nodeName} node can't be inserted in parent node.`,
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (
+      (nodeType === NODE_TYPE.TEXT_NODE && parentType === NODE_TYPE.DOCUMENT_NODE) ||
+      (nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE && parentType !== NODE_TYPE.DOCUMENT_NODE)
+    ) {
+      throw DOMException.create(this._globalObject, [
+        `${nodeName} node can't be inserted in ${parentName} parent.`,
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (parentType === NODE_TYPE.DOCUMENT_NODE) {
+      const nodeChildren = domSymbolTree.childrenToArray(nodeImpl);
+      const parentChildren = domSymbolTree.childrenToArray(this);
+
+      switch (nodeType) {
+        case NODE_TYPE.DOCUMENT_FRAGMENT_NODE: {
+          const nodeChildrenElements = nodeChildren.filter(child => child.nodeType === NODE_TYPE.ELEMENT_NODE);
+          if (nodeChildrenElements.length > 1) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+
+          const hasNodeTextChildren = nodeChildren.some(child => child.nodeType === NODE_TYPE.TEXT_NODE);
+          if (hasNodeTextChildren) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+
+          if (
+            nodeChildrenElements.length === 1 &&
+            (
+              parentChildren.some(child => child.nodeType === NODE_TYPE.ELEMENT_NODE) ||
+              (childImpl && childImpl.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) ||
+              (
+                childImpl &&
+                domSymbolTree.nextSibling(childImpl) &&
+                domSymbolTree.nextSibling(childImpl).nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE
+              )
+            )
+          ) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+          break;
+        }
+
+        case NODE_TYPE.ELEMENT_NODE:
+          if (
+            parentChildren.some(child => child.nodeType === NODE_TYPE.ELEMENT_NODE) ||
+            (childImpl && childImpl.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) ||
+            (
+              childImpl &&
+              domSymbolTree.nextSibling(childImpl) &&
+              domSymbolTree.nextSibling(childImpl).nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE
+            )
+          ) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+          break;
+
+        case NODE_TYPE.DOCUMENT_TYPE_NODE:
+          if (
+            parentChildren.some(child => child.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) ||
+            (
+              childImpl &&
+              domSymbolTree.previousSibling(childImpl) &&
+              domSymbolTree.previousSibling(childImpl).nodeType === NODE_TYPE.ELEMENT_NODE
+            ) ||
+            (!childImpl && parentChildren.some(child => child.nodeType === NODE_TYPE.ELEMENT_NODE))
+          ) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+          break;
+      }
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-pre-insert
+  _preInsert(nodeImpl, childImpl) {
+    this._preInsertValidity(nodeImpl, childImpl);
+
+    let referenceChildImpl = childImpl;
+    if (referenceChildImpl === nodeImpl) {
+      referenceChildImpl = domSymbolTree.nextSibling(nodeImpl);
+    }
+
+    this._ownerDocument._adoptNode(nodeImpl);
+
+    this._insert(nodeImpl, referenceChildImpl);
+
+    return nodeImpl;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-insert
+  _insert(nodeImpl, childImpl, suppressObservers) {
+    const count = nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE ?
+        domSymbolTree.childrenCount(nodeImpl) :
+        1;
+
+    if (childImpl) {
+      const childIndex = domSymbolTree.index(childImpl);
+
+      for (const range of this._referencedRanges) {
+        const { _start, _end } = range;
+
+        if (_start.offset > childIndex) {
+          range._setLiveRangeStart(this, _start.offset + count);
+        }
+
+        if (_end.offset > childIndex) {
+          range._setLiveRangeEnd(this, _end.offset + count);
+        }
+      }
+    }
+
+    const nodesImpl = nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE ?
+      domSymbolTree.childrenToArray(nodeImpl) :
+      [nodeImpl];
+
+    if (nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE) {
+      let grandChildImpl;
+      while ((grandChildImpl = domSymbolTree.firstChild(nodeImpl))) {
+        nodeImpl._remove(grandChildImpl, true);
+      }
+    }
+
+    if (nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE) {
+      queueTreeMutationRecord(nodeImpl, [], nodesImpl, null, null);
+    }
+
+    const previousChildImpl = childImpl ?
+      domSymbolTree.previousSibling(childImpl) :
+      domSymbolTree.lastChild(this);
+
+    for (const node of nodesImpl) {
+      if (!childImpl) {
+        domSymbolTree.appendChild(this, node);
+      } else {
+        domSymbolTree.insertBefore(childImpl, node);
+      }
+
+      if (
+        (this.nodeType === NODE_TYPE.ELEMENT_NODE && this._shadowRoot !== null) &&
+        (node.nodeType === NODE_TYPE.ELEMENT_NODE || node.nodeType === NODE_TYPE.TEXT_NODE)
+      ) {
+        assignSlot(node);
+      }
+
+      this._modified();
+
+      if (node.nodeType === NODE_TYPE.TEXT_NODE ||
+          node.nodeType === NODE_TYPE.CDATA_SECTION_NODE) {
+        this._childTextContentChangeSteps();
+      }
+
+      if (isSlot(this) && this._assignedNodes.length === 0 && isShadowRoot(nodeRoot(this))) {
+        signalSlotChange(this);
+      }
+
+      const root = nodeRoot(node);
+      if (isShadowRoot(root)) {
+        assignSlotableForTree(root);
+      }
+
+      if (this._attached && nodeImpl._attach) {
+        node._attach();
+      }
+
+      this._descendantAdded(this, node);
+
+      for (const inclusiveDescendant of shadowIncludingInclusiveDescendantsIterator(node)) {
+        if (inclusiveDescendant.isConnected) {
+          if (inclusiveDescendant._ceState === "custom") {
+            enqueueCECallbackReaction(inclusiveDescendant, "connectedCallback", []);
+          } else {
+            tryUpgradeElement(inclusiveDescendant);
+          }
+        }
+      }
+    }
+
+    if (!suppressObservers) {
+      queueTreeMutationRecord(this, nodesImpl, [], previousChildImpl, childImpl);
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-append
+  _append(nodeImpl) {
+    return this._preInsert(nodeImpl, null);
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-replace
+  _replace(nodeImpl, childImpl) {
+    const { nodeType, nodeName } = nodeImpl;
+    const { nodeType: parentType, nodeName: parentName } = this;
+
+    // Note: This section differs from the pre-insert validation algorithm.
+    if (
+      parentType !== NODE_TYPE.DOCUMENT_NODE &&
+      parentType !== NODE_TYPE.DOCUMENT_FRAGMENT_NODE &&
+      parentType !== NODE_TYPE.ELEMENT_NODE
+    ) {
+      throw DOMException.create(this._globalObject, [
+        `Node can't be inserted in a ${parentName} parent.`,
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (isHostInclusiveAncestor(nodeImpl, this)) {
+      throw DOMException.create(this._globalObject, [
+        "The operation would yield an incorrect node tree.",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (childImpl && domSymbolTree.parent(childImpl) !== this) {
+      throw DOMException.create(this._globalObject, [
+        "The child can not be found in the parent.",
+        "NotFoundError"
+      ]);
+    }
+
+    if (
+      nodeType !== NODE_TYPE.DOCUMENT_FRAGMENT_NODE &&
+      nodeType !== NODE_TYPE.DOCUMENT_TYPE_NODE &&
+      nodeType !== NODE_TYPE.ELEMENT_NODE &&
+      nodeType !== NODE_TYPE.TEXT_NODE &&
+      nodeType !== NODE_TYPE.CDATA_SECTION_NODE && // CData section extends from Text
+      nodeType !== NODE_TYPE.PROCESSING_INSTRUCTION_NODE &&
+      nodeType !== NODE_TYPE.COMMENT_NODE
+    ) {
+      throw DOMException.create(this._globalObject, [
+        `${nodeName} node can't be inserted in parent node.`,
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (
+      (nodeType === NODE_TYPE.TEXT_NODE && parentType === NODE_TYPE.DOCUMENT_NODE) ||
+      (nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE && parentType !== NODE_TYPE.DOCUMENT_NODE)
+    ) {
+      throw DOMException.create(this._globalObject, [
+        `${nodeName} node can't be inserted in ${parentName} parent.`,
+        "HierarchyRequestError"
+      ]);
+    }
+
+    if (parentType === NODE_TYPE.DOCUMENT_NODE) {
+      const nodeChildren = domSymbolTree.childrenToArray(nodeImpl);
+      const parentChildren = domSymbolTree.childrenToArray(this);
+
+      switch (nodeType) {
+        case NODE_TYPE.DOCUMENT_FRAGMENT_NODE: {
+          const nodeChildrenElements = nodeChildren.filter(child => child.nodeType === NODE_TYPE.ELEMENT_NODE);
+          if (nodeChildrenElements.length > 1) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+
+          const hasNodeTextChildren = nodeChildren.some(child => child.nodeType === NODE_TYPE.TEXT_NODE);
+          if (hasNodeTextChildren) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+
+
+          const parentChildElements = parentChildren.filter(child => child.nodeType === NODE_TYPE.ELEMENT_NODE);
+          if (
+            nodeChildrenElements.length === 1 &&
+            (
+              (parentChildElements.length === 1 && parentChildElements[0] !== childImpl) ||
+              (
+                childImpl &&
+                domSymbolTree.nextSibling(childImpl) &&
+                domSymbolTree.nextSibling(childImpl).nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE
+              )
+            )
+          ) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+          break;
+        }
+
+        case NODE_TYPE.ELEMENT_NODE:
+          if (
+            parentChildren.some(child => child.nodeType === NODE_TYPE.ELEMENT_NODE && child !== childImpl) ||
+            (
+              childImpl &&
+              domSymbolTree.nextSibling(childImpl) &&
+              domSymbolTree.nextSibling(childImpl).nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE
+            )
+          ) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+          break;
+
+        case NODE_TYPE.DOCUMENT_TYPE_NODE:
+          if (
+            parentChildren.some(child => child.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE && child !== childImpl) ||
+            (
+              childImpl &&
+              domSymbolTree.previousSibling(childImpl) &&
+              domSymbolTree.previousSibling(childImpl).nodeType === NODE_TYPE.ELEMENT_NODE
+            )
+          ) {
+            throw DOMException.create(this._globalObject, [
+              `Invalid insertion of ${nodeName} node in ${parentName} node.`,
+              "HierarchyRequestError"
+            ]);
+          }
+          break;
+      }
+    }
+
+    let referenceChildImpl = domSymbolTree.nextSibling(childImpl);
+    if (referenceChildImpl === nodeImpl) {
+      referenceChildImpl = domSymbolTree.nextSibling(nodeImpl);
+    }
+
+    const previousSiblingImpl = domSymbolTree.previousSibling(childImpl);
+
+    this._ownerDocument._adoptNode(nodeImpl);
+
+    let removedNodesImpl = [];
+
+    if (domSymbolTree.parent(childImpl)) {
+      removedNodesImpl = [childImpl];
+      this._remove(childImpl, true);
+    }
+
+    const nodesImpl = nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE ?
+      domSymbolTree.childrenToArray(nodeImpl) :
+      [nodeImpl];
+
+    this._insert(nodeImpl, referenceChildImpl, true);
+
+    queueTreeMutationRecord(this, nodesImpl, removedNodesImpl, previousSiblingImpl, referenceChildImpl);
+
+    return childImpl;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-replace-all
+  _replaceAll(nodeImpl) {
+    if (nodeImpl !== null) {
+      this._ownerDocument._adoptNode(nodeImpl);
+    }
+
+    const removedNodesImpl = domSymbolTree.childrenToArray(this);
+
+    let addedNodesImpl;
+    if (nodeImpl === null) {
+      addedNodesImpl = [];
+    } else if (nodeImpl.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE) {
+      addedNodesImpl = domSymbolTree.childrenToArray(nodeImpl);
+    } else {
+      addedNodesImpl = [nodeImpl];
+    }
+
+    for (const childImpl of domSymbolTree.childrenIterator(this)) {
+      this._remove(childImpl, true);
+    }
+
+    if (nodeImpl !== null) {
+      this._insert(nodeImpl, null, true);
+    }
+
+    if (addedNodesImpl.length > 0 || removedNodesImpl.length > 0) {
+      queueTreeMutationRecord(this, addedNodesImpl, removedNodesImpl, null, null);
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-pre-remove
+  _preRemove(childImpl) {
+    if (domSymbolTree.parent(childImpl) !== this) {
+      throw DOMException.create(this._globalObject, [
+        "The node to be removed is not a child of this node.",
+        "NotFoundError"
+      ]);
+    }
+
+    this._remove(childImpl);
+
+    return childImpl;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-node-remove
+  _remove(nodeImpl, suppressObservers) {
+    const index = domSymbolTree.index(nodeImpl);
+
+    for (const descendant of domSymbolTree.treeIterator(nodeImpl)) {
+      for (const range of descendant._referencedRanges) {
+        const { _start, _end } = range;
+
+        if (_start.node === descendant) {
+          range._setLiveRangeStart(this, index);
+        }
+
+        if (_end.node === descendant) {
+          range._setLiveRangeEnd(this, index);
+        }
+      }
+    }
+
+    for (const range of this._referencedRanges) {
+      const { _start, _end } = range;
+
+      if (_start.node === this && _start.offset > index) {
+        range._setLiveRangeStart(this, _start.offset - 1);
+      }
+
+      if (_end.node === this && _end.offset > index) {
+        range._setLiveRangeEnd(this, _end.offset - 1);
+      }
+    }
+
+    if (this._ownerDocument) {
+      this._ownerDocument._runPreRemovingSteps(nodeImpl);
+    }
+
+    const oldPreviousSiblingImpl = domSymbolTree.previousSibling(nodeImpl);
+    const oldNextSiblingImpl = domSymbolTree.nextSibling(nodeImpl);
+
+    domSymbolTree.remove(nodeImpl);
+
+    if (nodeImpl._assignedSlot) {
+      assignSlotable(nodeImpl._assignedSlot);
+    }
+
+    if (isSlot(this) && this._assignedNodes.length === 0 && isShadowRoot(nodeRoot(this))) {
+      signalSlotChange(this);
+    }
+
+    let hasSlotDescendant = isSlot(nodeImpl);
+    if (!hasSlotDescendant) {
+      for (const child of domSymbolTree.treeIterator(nodeImpl)) {
+        if (isSlot(child)) {
+          hasSlotDescendant = true;
+          break;
+        }
+      }
+    }
+
+    if (hasSlotDescendant) {
+      assignSlotableForTree(nodeRoot(this));
+      assignSlotableForTree(nodeImpl);
+    }
+
+    this._modified();
+    nodeImpl._detach();
+    this._descendantRemoved(this, nodeImpl);
+
+    if (this.isConnected) {
+      if (nodeImpl._ceState === "custom") {
+        enqueueCECallbackReaction(nodeImpl, "disconnectedCallback", []);
+      }
+
+      for (const descendantImpl of shadowIncludingDescendantsIterator(nodeImpl)) {
+        if (descendantImpl._ceState === "custom") {
+          enqueueCECallbackReaction(descendantImpl, "disconnectedCallback", []);
+        }
+      }
+    }
+
+    if (!suppressObservers) {
+      queueTreeMutationRecord(this, [], [nodeImpl], oldPreviousSiblingImpl, oldNextSiblingImpl);
+    }
+
+    if (nodeImpl.nodeType === NODE_TYPE.TEXT_NODE) {
+      this._childTextContentChangeSteps();
+    }
+  }
+}
+
+module.exports = {
+  implementation: NodeImpl
+};
diff --git a/lib/jsdom/living/nodes/NodeList-impl.js b/lib/jsdom/living/nodes/NodeList-impl.js
new file mode 100644
index 0000000..6f83035
--- /dev/null
+++ b/lib/jsdom/living/nodes/NodeList-impl.js
@@ -0,0 +1,43 @@
+"use strict";
+
+const idlUtils = require("../generated/utils.js");
+
+exports.implementation = class NodeListImpl {
+  constructor(globalObject, args, privateData) {
+    if (privateData.nodes) {
+      this._list = [...privateData.nodes];
+      this._isLive = false;
+    } else {
+      this._list = [];
+      this._isLive = true;
+      this._version = -1;
+      this._element = privateData.element;
+      this._query = privateData.query;
+      this._update();
+    }
+  }
+  get length() {
+    this._update();
+    return this._list.length;
+  }
+  item(index) {
+    this._update();
+    return this._list[index] || null;
+  }
+  _update() {
+    if (this._isLive) {
+      if (this._version < this._element._version) {
+        const snapshot = this._query();
+        for (let i = 0; i < snapshot.length; i++) {
+          this._list[i] = snapshot[i];
+        }
+        this._list.length = snapshot.length;
+        this._version = this._element._version;
+      }
+    }
+  }
+  get [idlUtils.supportedPropertyIndices]() {
+    this._update();
+    return this._list.keys();
+  }
+};
diff --git a/lib/jsdom/living/nodes/NonDocumentTypeChildNode-impl.js b/lib/jsdom/living/nodes/NonDocumentTypeChildNode-impl.js
new file mode 100644
index 0000000..21bbb15
--- /dev/null
+++ b/lib/jsdom/living/nodes/NonDocumentTypeChildNode-impl.js
@@ -0,0 +1,28 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+
+class NonDocumentTypeChildNodeImpl {
+  get nextElementSibling() {
+    for (const sibling of domSymbolTree.nextSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+
+  get previousElementSibling() {
+    for (const sibling of domSymbolTree.previousSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  implementation: NonDocumentTypeChildNodeImpl
+};
diff --git a/lib/jsdom/living/nodes/NonElementParentNode-impl.js b/lib/jsdom/living/nodes/NonElementParentNode-impl.js
new file mode 100644
index 0000000..ca8d578
--- /dev/null
+++ b/lib/jsdom/living/nodes/NonElementParentNode-impl.js
@@ -0,0 +1,11 @@
+"use strict";
+
+// https://dom.spec.whatwg.org/#interface-nonelementparentnode
+// getElementById is implemented separately inside Document and DocumentFragment.
+class NonElementParentNodeImpl {
+
+}
+
+module.exports = {
+  implementation: NonElementParentNodeImpl
+};
diff --git a/lib/jsdom/living/nodes/ParentNode-impl.js b/lib/jsdom/living/nodes/ParentNode-impl.js
new file mode 100644
index 0000000..088306d
--- /dev/null
+++ b/lib/jsdom/living/nodes/ParentNode-impl.js
@@ -0,0 +1,85 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+const NodeList = require("../generated/NodeList");
+const HTMLCollection = require("../generated/HTMLCollection");
+const { addNwsapi } = require("../helpers/selectors");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+const { convertNodesIntoNode } = require("../node");
+
+class ParentNodeImpl {
+  get children() {
+    if (!this._childrenList) {
+      this._childrenList = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => domSymbolTree.childrenToArray(this, {
+          filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE
+        })
+      });
+    } else {
+      this._childrenList._update();
+    }
+    return this._childrenList;
+  }
+
+  get firstElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get lastElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this, { reverse: true })) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get childElementCount() {
+    return this.children.length;
+  }
+
+  prepend(...nodes) {
+    this._preInsert(convertNodesIntoNode(this._ownerDocument, nodes), this.firstChild);
+  }
+
+  append(...nodes) {
+    this._append(convertNodesIntoNode(this._ownerDocument, nodes));
+  }
+
+  querySelector(selectors) {
+    if (shouldAlwaysSelectNothing(this)) {
+      return null;
+    }
+    const matcher = addNwsapi(this);
+    return idlUtils.implForWrapper(matcher.first(selectors, idlUtils.wrapperForImpl(this)));
+  }
+
+  // Warning for internal users: this returns a NodeList containing IDL wrappers instead of impls
+  querySelectorAll(selectors) {
+    if (shouldAlwaysSelectNothing(this)) {
+      return NodeList.create(this._globalObject, [], { nodes: [] });
+    }
+    const matcher = addNwsapi(this);
+    const list = matcher.select(selectors, idlUtils.wrapperForImpl(this));
+
+    return NodeList.create(this._globalObject, [], { nodes: list.map(n => idlUtils.tryImplForWrapper(n)) });
+  }
+}
+
+function shouldAlwaysSelectNothing(elImpl) {
+  // This is true during initialization.
+  return elImpl === elImpl._ownerDocument && !elImpl.documentElement;
+}
+
+module.exports = {
+  implementation: ParentNodeImpl
+};
diff --git a/lib/jsdom/living/nodes/ProcessingInstruction-impl.js b/lib/jsdom/living/nodes/ProcessingInstruction-impl.js
new file mode 100644
index 0000000..348dadc
--- /dev/null
+++ b/lib/jsdom/living/nodes/ProcessingInstruction-impl.js
@@ -0,0 +1,22 @@
+"use strict";
+
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const NODE_TYPE = require("../node-type");
+
+class ProcessingInstructionImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.nodeType = NODE_TYPE.PROCESSING_INSTRUCTION_NODE;
+    this._target = privateData.target;
+  }
+
+  get target() {
+    return this._target;
+  }
+}
+
+module.exports = {
+  implementation: ProcessingInstructionImpl
+};
diff --git a/lib/jsdom/living/nodes/SVGElement-impl.js b/lib/jsdom/living/nodes/SVGElement-impl.js
new file mode 100644
index 0000000..8a842b4
--- /dev/null
+++ b/lib/jsdom/living/nodes/SVGElement-impl.js
@@ -0,0 +1,64 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { SVG_NS } = require("../helpers/namespaces");
+const { mixin } = require("../../utils");
+const SVGAnimatedString = require("../generated/SVGAnimatedString");
+const ElementImpl = require("./Element-impl").implementation;
+const ElementCSSInlineStyleImpl = require("./ElementCSSInlineStyle-impl").implementation;
+const GlobalEventHandlersImpl = require("./GlobalEventHandlers-impl").implementation;
+const HTMLOrSVGElementImpl = require("./HTMLOrSVGElement-impl").implementation;
+
+class SVGElementImpl extends ElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._initHTMLOrSVGElement();
+    this._initElementCSSInlineStyle();
+    this._initGlobalEvents();
+  }
+
+  // Keep in sync with HTMLElement. https://github.com/jsdom/jsdom/issues/2599
+  _attrModified(name, value, oldValue) {
+    if (name === "style" && value !== oldValue && !this._settingCssText) {
+      this._settingCssText = true;
+      this._style.cssText = value;
+      this._settingCssText = false;
+    } else if (name.startsWith("on")) {
+      this._globalEventChanged(name.substring(2));
+    }
+
+    super._attrModified.apply(this, arguments);
+  }
+
+  get className() {
+    return SVGAnimatedString.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "class"
+    });
+  }
+
+  get ownerSVGElement() {
+    let e = domSymbolTree.parent(this);
+    while (e && e.namespaceURI === SVG_NS) {
+      if (e.localName === "svg") {
+        return e;
+      }
+      e = domSymbolTree.parent(e);
+    }
+
+    return null;
+  }
+
+  get viewportElement() {
+    // TODO: <symbol>/<use> may make this different from ownerSVGElement.
+    return this.ownerSVGElement;
+  }
+}
+
+SVGElementImpl.attributeRegistry = new Map();
+
+mixin(SVGElementImpl.prototype, ElementCSSInlineStyleImpl.prototype);
+mixin(SVGElementImpl.prototype, GlobalEventHandlersImpl.prototype);
+mixin(SVGElementImpl.prototype, HTMLOrSVGElementImpl.prototype);
+
+exports.implementation = SVGElementImpl;
diff --git a/lib/jsdom/living/nodes/SVGGraphicsElement-impl.js b/lib/jsdom/living/nodes/SVGGraphicsElement-impl.js
new file mode 100644
index 0000000..ef0ec1d
--- /dev/null
+++ b/lib/jsdom/living/nodes/SVGGraphicsElement-impl.js
@@ -0,0 +1,16 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+const SVGTestsImpl = require("./SVGTests-impl").implementation;
+
+class SVGGraphicsElementImpl extends SVGElementImpl {}
+
+SVGGraphicsElementImpl.attributeRegistry = new Map([
+  ...SVGElementImpl.attributeRegistry,
+  ...SVGTestsImpl.attributeRegistry
+]);
+
+mixin(SVGGraphicsElementImpl.prototype, SVGTestsImpl.prototype);
+
+exports.implementation = SVGGraphicsElementImpl;
diff --git a/lib/jsdom/living/nodes/SVGSVGElement-impl.js b/lib/jsdom/living/nodes/SVGSVGElement-impl.js
new file mode 100644
index 0000000..5dbc9e3
--- /dev/null
+++ b/lib/jsdom/living/nodes/SVGSVGElement-impl.js
@@ -0,0 +1,42 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const SVGNumber = require("../generated/SVGNumber");
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+const WindowEventHandlersImpl = require("./WindowEventHandlers-impl").implementation;
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { ELEMENT_NODE } = require("../node-type");
+
+class SVGSVGElementImpl extends SVGGraphicsElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._proxyWindowEventsToWindow();
+  }
+
+  createSVGNumber() {
+    return SVGNumber.createImpl(this._globalObject, [], {});
+  }
+
+  getElementById(elementId) {
+    // TODO: optimize with _ids caching trick; see Document class.
+    for (const node of domSymbolTree.treeIterator(this)) {
+      if (node.nodeType === ELEMENT_NODE && node.getAttributeNS(null, "id") === elementId) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  suspendRedraw() {
+    return 1;
+  }
+  unsuspendRedraw() {}
+  unsuspendRedrawAll() {}
+  forceRedraw() {}
+}
+
+mixin(SVGSVGElementImpl.prototype, WindowEventHandlersImpl.prototype);
+
+module.exports = {
+  implementation: SVGSVGElementImpl
+};
diff --git a/lib/jsdom/living/nodes/SVGTests-impl.js b/lib/jsdom/living/nodes/SVGTests-impl.js
new file mode 100644
index 0000000..6ff1182
--- /dev/null
+++ b/lib/jsdom/living/nodes/SVGTests-impl.js
@@ -0,0 +1,42 @@
+"use strict";
+
+const { splitOnASCIIWhitespace, splitOnCommas } = require("../helpers/strings");
+const { reserializeCommaSeparatedTokens, reserializeSpaceSeparatedTokens } = require("../helpers/svg/basic-types");
+const SVGStringList = require("../generated/SVGStringList");
+
+class SVGTestsImpl {
+  get requiredExtensions() {
+    return SVGStringList.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "requiredExtensions"
+    });
+  }
+
+  get systemLanguage() {
+    return SVGStringList.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "systemLanguage"
+    });
+  }
+}
+
+SVGTestsImpl.attributeRegistry = new Map([
+  // https://svgwg.org/svg2-draft/struct.html#RequiredExtensionsAttribute
+  [
+    "requiredExtensions", {
+      getValue: splitOnASCIIWhitespace,
+      serialize: reserializeSpaceSeparatedTokens,
+      initialValue: undefined
+    }
+  ],
+  // https://svgwg.org/svg2-draft/struct.html#SystemLanguageAttribute
+  [
+    "systemLanguage", {
+      getValue: splitOnCommas,
+      serialize: reserializeCommaSeparatedTokens,
+      initialValue: undefined
+    }
+  ]
+]);
+
+exports.implementation = SVGTestsImpl;
diff --git a/lib/jsdom/living/nodes/SVGTitleElement-impl.js b/lib/jsdom/living/nodes/SVGTitleElement-impl.js
new file mode 100644
index 0000000..7a9187d
--- /dev/null
+++ b/lib/jsdom/living/nodes/SVGTitleElement-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+
+class SVGTitleElementImpl extends SVGElementImpl { }
+
+module.exports = {
+  implementation: SVGTitleElementImpl
+};
diff --git a/lib/jsdom/living/nodes/ShadowRoot-impl.js b/lib/jsdom/living/nodes/ShadowRoot-impl.js
new file mode 100644
index 0000000..eda9a20
--- /dev/null
+++ b/lib/jsdom/living/nodes/ShadowRoot-impl.js
@@ -0,0 +1,52 @@
+"use strict";
+
+const { parseFragment } = require("../../browser/parser");
+const { fragmentSerialization } = require("../domparsing/serialization.js");
+const { nodeRoot } = require("../helpers/node");
+const { mixin } = require("../../utils");
+
+const DocumentFragment = require("./DocumentFragment-impl").implementation;
+const DocumentOrShadowRootImpl = require("./DocumentOrShadowRoot-impl").implementation;
+
+class ShadowRootImpl extends DocumentFragment {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const { mode } = privateData;
+    this._mode = mode;
+  }
+
+  _getTheParent(event) {
+    if (!event.composed && this === nodeRoot(event._path[0].item)) {
+      return null;
+    }
+
+    return this._host;
+  }
+
+  get mode() {
+    return this._mode;
+  }
+
+  get host() {
+    return this._host;
+  }
+
+  // https://w3c.github.io/DOM-Parsing/#dfn-innerhtml
+  get innerHTML() {
+    return fragmentSerialization(this, {
+      requireWellFormed: true,
+      globalObject: this._globalObject
+    });
+  }
+  set innerHTML(markup) {
+    const fragment = parseFragment(markup, this._host);
+    this._replaceAll(fragment);
+  }
+}
+
+mixin(ShadowRootImpl.prototype, DocumentOrShadowRootImpl.prototype);
+
+module.exports = {
+  implementation: ShadowRootImpl
+};
diff --git a/lib/jsdom/living/nodes/Slotable-impl.js b/lib/jsdom/living/nodes/Slotable-impl.js
new file mode 100644
index 0000000..5746a01
--- /dev/null
+++ b/lib/jsdom/living/nodes/Slotable-impl.js
@@ -0,0 +1,48 @@
+"use strict";
+
+const { findSlot, assignSlot, assignSlotable } = require("../helpers/shadow-dom");
+
+// https://dom.spec.whatwg.org/#mixin-slotable
+// https://dom.spec.whatwg.org/#light-tree-slotables
+class SlotableMixinImpl {
+  _initSlotableMixin() {
+    this._slotableName = "";
+  }
+
+  _attrModifiedSlotableMixin(name, value, oldValue) {
+    if (name === "slot") {
+      if (value === oldValue) {
+        return;
+      }
+
+      if (value === null && oldValue === "") {
+        return;
+      }
+
+      if (value === "" && oldValue === null) {
+        return;
+      }
+
+      if (value === null || value === "") {
+        this._slotableName = "";
+      } else {
+        this._slotableName = value;
+      }
+
+
+      if (this._assignedSlot) {
+        assignSlotable(this._assignedSlot);
+      }
+
+      assignSlot(this);
+    }
+  }
+
+  get assignedSlot() {
+    return findSlot(this, "open");
+  }
+}
+
+module.exports = {
+  implementation: SlotableMixinImpl
+};
diff --git a/lib/jsdom/living/nodes/Text-impl.js b/lib/jsdom/living/nodes/Text-impl.js
new file mode 100644
index 0000000..905ca94
--- /dev/null
+++ b/lib/jsdom/living/nodes/Text-impl.js
@@ -0,0 +1,96 @@
+"use strict";
+
+const SlotableMixinImpl = require("./Slotable-impl").implementation;
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const DOMException = require("domexception/webidl2js-wrapper");
+const NODE_TYPE = require("../node-type");
+const { mixin } = require("../../utils");
+
+// https://dom.spec.whatwg.org/#text
+class TextImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, {
+      data: args[0],
+      ...privateData
+    });
+
+    this._initSlotableMixin();
+
+    this.nodeType = NODE_TYPE.TEXT_NODE;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-text-splittext
+  // https://dom.spec.whatwg.org/#concept-text-split
+  splitText(offset) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    const count = length - offset;
+    const newData = this.substringData(offset, count);
+
+    const newNode = this._ownerDocument.createTextNode(newData);
+
+    const parent = domSymbolTree.parent(this);
+
+    if (parent !== null) {
+      parent._insert(newNode, this.nextSibling);
+
+      for (const range of this._referencedRanges) {
+        const { _start, _end } = range;
+
+        if (_start.node === this && _start.offset > offset) {
+          range._setLiveRangeStart(newNode, _start.offset - offset);
+        }
+
+        if (_end.node === this && _end.offset > offset) {
+          range._setLiveRangeEnd(newNode, _end.offset - offset);
+        }
+      }
+
+      const nodeIndex = domSymbolTree.index(this);
+      for (const range of parent._referencedRanges) {
+        const { _start, _end } = range;
+
+        if (_start.node === parent && _start.offset === nodeIndex + 1) {
+          range._setLiveRangeStart(parent, _start.offset + 1);
+        }
+
+        if (_end.node === parent && _end.offset === nodeIndex + 1) {
+          range._setLiveRangeEnd(parent, _end.offset + 1);
+        }
+      }
+    }
+
+    this.replaceData(offset, count, "");
+
+    return newNode;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-text-wholetext
+  get wholeText() {
+    let wholeText = this.textContent;
+    let next;
+    let current = this;
+    while ((next = domSymbolTree.previousSibling(current)) && next.nodeType === NODE_TYPE.TEXT_NODE) {
+      wholeText = next.textContent + wholeText;
+      current = next;
+    }
+    current = this;
+    while ((next = domSymbolTree.nextSibling(current)) && next.nodeType === NODE_TYPE.TEXT_NODE) {
+      wholeText += next.textContent;
+      current = next;
+    }
+    return wholeText;
+  }
+}
+
+mixin(TextImpl.prototype, SlotableMixinImpl.prototype);
+
+module.exports = {
+  implementation: TextImpl
+};
diff --git a/lib/jsdom/living/nodes/WindowEventHandlers-impl.js b/lib/jsdom/living/nodes/WindowEventHandlers-impl.js
new file mode 100644
index 0000000..bce1989
--- /dev/null
+++ b/lib/jsdom/living/nodes/WindowEventHandlers-impl.js
@@ -0,0 +1,52 @@
+"use strict";
+
+const { createEventAccessor } = require("../helpers/create-event-accessor");
+
+const events = new Set([
+  // WindowEventHandlers
+  "afterprint",
+  "beforeprint",
+  "beforeunload",
+  "hashchange",
+  "languagechange",
+  "message",
+  "messageerror",
+  "offline",
+  "online",
+  "pagehide",
+  "pageshow",
+  "popstate",
+  "rejectionhandled",
+  "storage",
+  "unhandledrejection",
+  "unload",
+
+  // inherited and overridden
+  "blur",
+  "error",
+  "focus",
+  "load",
+  "resize",
+  "scroll"
+]);
+
+// This class builds on GlobalEventHandlers, which must be mixed in first.
+class WindowEventHandlersImpl {
+  _proxyWindowEventsToWindow() {
+    // We're a <body> or <frameset>, so we need to proxy these specific events to the Window (if it exists)
+    this._getEventHandlerTarget = event => {
+      if (events.has(event)) {
+        return this.ownerDocument.defaultView || null;
+      }
+      return this;
+    };
+  }
+}
+
+for (const event of events) {
+  createEventAccessor(WindowEventHandlersImpl.prototype, event);
+}
+
+module.exports = {
+  implementation: WindowEventHandlersImpl
+};
diff --git a/lib/jsdom/living/nodes/XMLDocument-impl.js b/lib/jsdom/living/nodes/XMLDocument-impl.js
new file mode 100644
index 0000000..487db01
--- /dev/null
+++ b/lib/jsdom/living/nodes/XMLDocument-impl.js
@@ -0,0 +1,4 @@
+"use strict";
+const DocumentImpl = require("./Document-impl").implementation;
+
+exports.implementation = class XMLDocumentImpl extends DocumentImpl {};
diff --git a/lib/jsdom/living/post-message.js b/lib/jsdom/living/post-message.js
new file mode 100644
index 0000000..db16576
--- /dev/null
+++ b/lib/jsdom/living/post-message.js
@@ -0,0 +1,39 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const MessageEvent = require("./generated/MessageEvent");
+const idlUtils = require("./generated/utils");
+const { isValidTargetOrigin } = require("../utils");
+const { fireAnEvent } = require("./helpers/events");
+
+module.exports = function (globalObject) {
+  return function (message, targetOrigin) {
+    if (arguments.length < 2) {
+      throw new TypeError("'postMessage' requires 2 arguments: 'message' and 'targetOrigin'");
+    }
+
+    targetOrigin = String(targetOrigin);
+
+    if (!isValidTargetOrigin(targetOrigin)) {
+      // TODO: Fix me
+      throw DOMException.create(globalObject, [
+        "Failed to execute 'postMessage' on 'Window': " +
+        "Invalid target origin '" + targetOrigin + "' in a call to 'postMessage'.",
+        "SyntaxError"
+      ]);
+    }
+
+    // TODO: targetOrigin === '/' - requires reference to source window
+    // See https://github.com/jsdom/jsdom/pull/1140#issuecomment-111587499
+    if (targetOrigin !== "*" && targetOrigin !== idlUtils.implForWrapper(globalObject._document)._origin) {
+      return;
+    }
+
+    // TODO: event.source - requires reference to source window
+    // TODO: event.origin - requires reference to source window
+    // TODO: event.ports
+    // TODO: event.data - structured clone message - requires cloning DOM nodes
+    setTimeout(() => {
+      fireAnEvent("message", this, MessageEvent, { data: message });
+    }, 0);
+  };
+};
diff --git a/lib/jsdom/living/range/AbstractRange-impl.js b/lib/jsdom/living/range/AbstractRange-impl.js
new file mode 100644
index 0000000..55a0719
--- /dev/null
+++ b/lib/jsdom/living/range/AbstractRange-impl.js
@@ -0,0 +1,43 @@
+"use strict";
+
+// https://dom.spec.whatwg.org/#abstractrange
+class AbstractRangeImpl {
+  constructor(globalObject, args, privateData) {
+    const { start, end } = privateData;
+
+    this._start = start;
+    this._end = end;
+
+    this._globalObject = globalObject;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-startcontainer
+  get startContainer() {
+    return this._start.node;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-startoffset
+  get startOffset() {
+    return this._start.offset;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-endcontainer
+  get endContainer() {
+    return this._end.node;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-endoffset
+  get endOffset() {
+    return this._end.offset;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-collapsed
+  get collapsed() {
+    const { _start, _end } = this;
+    return _start.node === _end.node && _start.offset === _end.offset;
+  }
+}
+
+module.exports = {
+  implementation: AbstractRangeImpl
+};
diff --git a/lib/jsdom/living/range/Range-impl.js b/lib/jsdom/living/range/Range-impl.js
new file mode 100644
index 0000000..ae2b8a6
--- /dev/null
+++ b/lib/jsdom/living/range/Range-impl.js
@@ -0,0 +1,892 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const { clone } = require("../node");
+const NODE_TYPE = require("../node-type");
+const { parseFragment } = require("../../browser/parser");
+
+const { HTML_NS } = require("../helpers/namespaces");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { compareBoundaryPointsPosition } = require("./boundary-point");
+const { nodeRoot, nodeLength, isInclusiveAncestor } = require("../helpers/node");
+const { createElement } = require("../helpers/create-element");
+
+const AbstractRangeImpl = require("./AbstractRange-impl").implementation;
+
+const Range = require("../generated/Range");
+const DocumentFragment = require("../generated/DocumentFragment");
+const { implForWrapper } = require("../generated/utils");
+
+const RANGE_COMPARISON_TYPE = {
+  START_TO_START: 0,
+  START_TO_END: 1,
+  END_TO_END: 2,
+  END_TO_START: 3
+};
+
+class RangeImpl extends AbstractRangeImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const defaultBoundaryPoint = {
+      node: implForWrapper(globalObject._document),
+      offset: 0
+    };
+
+    const {
+      start = defaultBoundaryPoint,
+      end = defaultBoundaryPoint
+    } = privateData;
+
+    this._setLiveRangeStart(start.node, start.offset);
+    this._setLiveRangeEnd(end.node, end.offset);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-commonancestorcontainer
+  get commonAncestorContainer() {
+    const { _start, _end } = this;
+
+    for (const container of domSymbolTree.ancestorsIterator(_start.node)) {
+      if (isInclusiveAncestor(container, _end.node)) {
+        return container;
+      }
+    }
+
+    return null;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-setstart
+  setStart(node, offset) {
+    setBoundaryPointStart(this, node, offset);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-setend
+  setEnd(node, offset) {
+    setBoundaryPointEnd(this, node, offset);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-setstartbefore
+  setStartBefore(node) {
+    const parent = domSymbolTree.parent(node);
+
+    if (!parent) {
+      throw DOMException.create(this._globalObject, ["The given Node has no parent.", "InvalidNodeTypeError"]);
+    }
+
+    setBoundaryPointStart(this, parent, domSymbolTree.index(node));
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-setstartafter
+  setStartAfter(node) {
+    const parent = domSymbolTree.parent(node);
+
+    if (!parent) {
+      throw DOMException.create(this._globalObject, ["The given Node has no parent.", "InvalidNodeTypeError"]);
+    }
+
+    setBoundaryPointStart(this, parent, domSymbolTree.index(node) + 1);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-setendbefore
+  setEndBefore(node) {
+    const parent = domSymbolTree.parent(node);
+
+    if (!parent) {
+      throw DOMException.create(this._globalObject, ["The given Node has no parent.", "InvalidNodeTypeError"]);
+    }
+
+    setBoundaryPointEnd(this, parent, domSymbolTree.index(node));
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-setendafter
+  setEndAfter(node) {
+    const parent = domSymbolTree.parent(node);
+
+    if (!parent) {
+      throw DOMException.create(this._globalObject, ["The given Node has no parent.", "InvalidNodeTypeError"]);
+    }
+
+    setBoundaryPointEnd(this, parent, domSymbolTree.index(node) + 1);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-collapse
+  collapse(toStart) {
+    if (toStart) {
+      this._setLiveRangeEnd(this._start.node, this._start.offset);
+    } else {
+      this._setLiveRangeStart(this._end.node, this._end.offset);
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-selectnode
+  selectNode(node) {
+    selectNodeWithinRange(node, this);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-selectnodecontents
+  selectNodeContents(node) {
+    if (node.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) {
+      throw DOMException.create(this._globalObject, [
+        "DocumentType Node can't be used as boundary point.",
+        "InvalidNodeTypeError"
+      ]);
+    }
+
+    const length = nodeLength(node);
+
+    this._setLiveRangeStart(node, 0);
+    this._setLiveRangeEnd(node, length);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-compareboundarypoints
+  compareBoundaryPoints(how, sourceRange) {
+    if (
+      how !== RANGE_COMPARISON_TYPE.START_TO_START &&
+      how !== RANGE_COMPARISON_TYPE.START_TO_END &&
+      how !== RANGE_COMPARISON_TYPE.END_TO_END &&
+      how !== RANGE_COMPARISON_TYPE.END_TO_START
+    ) {
+      const message = "The comparison method provided must be one of 'START_TO_START', 'START_TO_END', 'END_TO_END', " +
+                      "or 'END_TO_START'.";
+      throw DOMException.create(this._globalObject, [message, "NotSupportedError"]);
+    }
+
+    if (this._root !== sourceRange._root) {
+      throw DOMException.create(this._globalObject, ["The two Ranges are not in the same tree.", "WrongDocumentError"]);
+    }
+
+    let thisPoint;
+    let otherPoint;
+    if (how === RANGE_COMPARISON_TYPE.START_TO_START) {
+      thisPoint = this._start;
+      otherPoint = sourceRange._start;
+    } else if (how === RANGE_COMPARISON_TYPE.START_TO_END) {
+      thisPoint = this._end;
+      otherPoint = sourceRange._start;
+    } else if (how === RANGE_COMPARISON_TYPE.END_TO_END) {
+      thisPoint = this._end;
+      otherPoint = sourceRange._end;
+    } else {
+      thisPoint = this._start;
+      otherPoint = sourceRange._end;
+    }
+
+    return compareBoundaryPointsPosition(thisPoint, otherPoint);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-deletecontents
+  deleteContents() {
+    if (this.collapsed) {
+      return;
+    }
+
+    const { _start: originalStart, _end: originalEnd } = this;
+
+    if (
+      originalStart.node === originalEnd.node &&
+      (
+        originalStart.node.nodeType === NODE_TYPE.TEXT_NODE ||
+        originalStart.node.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+        originalStart.node.nodeType === NODE_TYPE.COMMENT_NODE
+      )
+    ) {
+      originalStart.node.replaceData(originalStart.offset, originalEnd.offset - originalStart.offset, "");
+      return;
+    }
+
+    const nodesToRemove = [];
+    let currentNode = this._start.node;
+    const endNode = nextNodeDescendant(this._end.node);
+    while (currentNode && currentNode !== endNode) {
+      if (
+        isContained(currentNode, this) &&
+        !isContained(domSymbolTree.parent(currentNode), this)
+      ) {
+        nodesToRemove.push(currentNode);
+      }
+
+      currentNode = domSymbolTree.following(currentNode);
+    }
+
+    let newNode;
+    let newOffset;
+    if (isInclusiveAncestor(originalStart.node, originalEnd.node)) {
+      newNode = originalStart.node;
+      newOffset = originalStart.offset;
+    } else {
+      let referenceNode = originalStart.node;
+
+      while (
+        referenceNode &&
+        !isInclusiveAncestor(domSymbolTree.parent(referenceNode), originalEnd.node)
+      ) {
+        referenceNode = domSymbolTree.parent(referenceNode);
+      }
+
+      newNode = domSymbolTree.parent(referenceNode);
+      newOffset = domSymbolTree.index(referenceNode) + 1;
+    }
+
+    if (
+      originalStart.node.nodeType === NODE_TYPE.TEXT_NODE ||
+      originalStart.node.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      originalStart.node.nodeType === NODE_TYPE.COMMENT_NODE
+    ) {
+      originalStart.node.replaceData(originalStart.offset, nodeLength(originalStart.node) - originalStart.offset, "");
+    }
+
+    for (const node of nodesToRemove) {
+      const parent = domSymbolTree.parent(node);
+      parent.removeChild(node);
+    }
+
+    if (
+      originalEnd.node.nodeType === NODE_TYPE.TEXT_NODE ||
+      originalEnd.node.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      originalEnd.node.nodeType === NODE_TYPE.COMMENT_NODE
+    ) {
+      originalEnd.node.replaceData(0, originalEnd.offset, "");
+    }
+
+    this._setLiveRangeStart(newNode, newOffset);
+    this._setLiveRangeEnd(newNode, newOffset);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-extractcontents
+  extractContents() {
+    return extractRange(this);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-clonecontents
+  cloneContents() {
+    return cloneRange(this);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-insertnode
+  insertNode(node) {
+    insertNodeInRange(node, this);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-surroundcontents
+  surroundContents(newParent) {
+    let node = this.commonAncestorContainer;
+    const endNode = nextNodeDescendant(node);
+    while (node !== endNode) {
+      if (node.nodeType !== NODE_TYPE.TEXT_NODE && isPartiallyContained(node, this)) {
+        throw DOMException.create(this._globalObject, [
+          "The Range has partially contains a non-Text node.",
+          "InvalidStateError"
+        ]);
+      }
+
+      node = domSymbolTree.following(node);
+    }
+
+    if (
+      newParent.nodeType === NODE_TYPE.DOCUMENT_NODE ||
+      newParent.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE ||
+      newParent.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE
+    ) {
+      throw DOMException.create(this._globalObject, ["Invalid element type.", "InvalidNodeTypeError"]);
+    }
+
+    const fragment = extractRange(this);
+
+    while (domSymbolTree.firstChild(newParent)) {
+      newParent.removeChild(domSymbolTree.firstChild(newParent));
+    }
+
+    insertNodeInRange(newParent, this);
+
+    newParent.appendChild(fragment);
+
+    selectNodeWithinRange(newParent, this);
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-clonerange
+  cloneRange() {
+    const { _start, _end, _globalObject } = this;
+
+    return Range.createImpl(_globalObject, [], {
+      start: { node: _start.node, offset: _start.offset },
+      end: { node: _end.node, offset: _end.offset }
+    });
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-detach
+  detach() {
+    // Do nothing by spec!
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-ispointinrange
+  isPointInRange(node, offset) {
+    if (nodeRoot(node) !== this._root) {
+      return false;
+    }
+
+    validateSetBoundaryPoint(node, offset);
+
+    const bp = { node, offset };
+
+    if (
+      compareBoundaryPointsPosition(bp, this._start) === -1 ||
+      compareBoundaryPointsPosition(bp, this._end) === 1
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-comparepoint
+  comparePoint(node, offset) {
+    if (nodeRoot(node) !== this._root) {
+      throw DOMException.create(this._globalObject, [
+        "The given Node and the Range are not in the same tree.",
+        "WrongDocumentError"
+      ]);
+    }
+
+    validateSetBoundaryPoint(node, offset);
+
+    const bp = { node, offset };
+    if (compareBoundaryPointsPosition(bp, this._start) === -1) {
+      return -1;
+    } else if (compareBoundaryPointsPosition(bp, this._end) === 1) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-intersectsnode
+  intersectsNode(node) {
+    if (nodeRoot(node) !== this._root) {
+      return false;
+    }
+
+    const parent = domSymbolTree.parent(node);
+    if (!parent) {
+      return true;
+    }
+
+    const offset = domSymbolTree.index(node);
+
+    return (
+      compareBoundaryPointsPosition({ node: parent, offset }, this._end) === -1 &&
+      compareBoundaryPointsPosition({ node: parent, offset: offset + 1 }, this._start) === 1
+    );
+  }
+
+  // https://dom.spec.whatwg.org/#dom-range-stringifier
+  toString() {
+    let s = "";
+    const { _start, _end } = this;
+
+    if (_start.node === _end.node && _start.node.nodeType === NODE_TYPE.TEXT_NODE) {
+      return _start.node.data.slice(_start.offset, _end.offset);
+    }
+
+    if (_start.node.nodeType === NODE_TYPE.TEXT_NODE) {
+      s += _start.node.data.slice(_start.offset);
+    }
+
+    let currentNode = _start.node;
+    const endNode = nextNodeDescendant(_end.node);
+    while (currentNode && currentNode !== endNode) {
+      if (currentNode.nodeType === NODE_TYPE.TEXT_NODE && isContained(currentNode, this)) {
+        s += currentNode.data;
+      }
+
+      currentNode = domSymbolTree.following(currentNode);
+    }
+
+    if (_end.node.nodeType === NODE_TYPE.TEXT_NODE) {
+      s += _end.node.data.slice(0, _end.offset);
+    }
+
+    return s;
+  }
+
+  // https://w3c.github.io/DOM-Parsing/#dom-range-createcontextualfragment
+  createContextualFragment(fragment) {
+    const { node } = this._start;
+
+    let element;
+    switch (node.nodeType) {
+      case NODE_TYPE.DOCUMENT_NODE:
+      case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+        element = null;
+        break;
+
+      case NODE_TYPE.ELEMENT_NODE:
+        element = node;
+        break;
+
+      case NODE_TYPE.TEXT_NODE:
+      case NODE_TYPE.COMMENT_NODE:
+        element = node.parentElement;
+        break;
+
+      default:
+        throw new Error("Internal error: Invalid range start node");
+    }
+
+    if (
+      element === null || (
+        element._ownerDocument._parsingMode === "html" &&
+        element._localName === "html" &&
+        element._namespaceURI === HTML_NS
+      )
+    ) {
+      element = createElement(node._ownerDocument, "body", HTML_NS);
+    }
+
+    return parseFragment(fragment, element);
+  }
+
+  // https://dom.spec.whatwg.org/#concept-range-root
+  get _root() {
+    return nodeRoot(this._start.node);
+  }
+
+  _setLiveRangeStart(node, offset) {
+    if (this._start && this._start.node !== node) {
+      this._start.node._referencedRanges.delete(this);
+    }
+
+    if (!node._referencedRanges.has(this)) {
+      node._referencedRanges.add(this);
+    }
+
+    this._start = {
+      node,
+      offset
+    };
+  }
+
+  _setLiveRangeEnd(node, offset) {
+    if (this._end && this._end.node !== node) {
+      this._end.node._referencedRanges.delete(this);
+    }
+
+    if (!node._referencedRanges.has(this)) {
+      node._referencedRanges.add(this);
+    }
+
+    this._end = {
+      node,
+      offset
+    };
+  }
+}
+
+
+function nextNodeDescendant(node) {
+  while (node && !domSymbolTree.nextSibling(node)) {
+    node = domSymbolTree.parent(node);
+  }
+
+  if (!node) {
+    return null;
+  }
+
+  return domSymbolTree.nextSibling(node);
+}
+
+// https://dom.spec.whatwg.org/#concept-range-bp-set
+function validateSetBoundaryPoint(node, offset) {
+  if (node.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) {
+    throw DOMException.create(node._globalObject, [
+      "DocumentType Node can't be used as boundary point.",
+      "InvalidNodeTypeError"
+    ]);
+  }
+
+  if (offset > nodeLength(node)) {
+    throw DOMException.create(node._globalObject, ["Offset out of bound.", "IndexSizeError"]);
+  }
+}
+function setBoundaryPointStart(range, node, offset) {
+  validateSetBoundaryPoint(node, offset);
+
+  const bp = { node, offset };
+  if (
+    nodeRoot(node) !== range._root ||
+    compareBoundaryPointsPosition(bp, range._end) === 1
+  ) {
+    range._setLiveRangeEnd(node, offset);
+  }
+
+  range._setLiveRangeStart(node, offset);
+}
+function setBoundaryPointEnd(range, node, offset) {
+  validateSetBoundaryPoint(node, offset);
+
+  const bp = { node, offset };
+  if (
+    nodeRoot(node) !== range._root ||
+    compareBoundaryPointsPosition(bp, range._start) === -1
+  ) {
+    range._setLiveRangeStart(node, offset);
+  }
+
+  range._setLiveRangeEnd(node, offset);
+}
+
+// https://dom.spec.whatwg.org/#concept-range-select
+function selectNodeWithinRange(node, range) {
+  const parent = domSymbolTree.parent(node);
+
+  if (!parent) {
+    throw DOMException.create(node._globalObject, ["The given Node has no parent.", "InvalidNodeTypeError"]);
+  }
+
+  const index = domSymbolTree.index(node);
+
+  range._setLiveRangeStart(parent, index);
+  range._setLiveRangeEnd(parent, index + 1);
+}
+
+// https://dom.spec.whatwg.org/#contained
+function isContained(node, range) {
+  const { _start, _end } = range;
+  return (
+    compareBoundaryPointsPosition({ node, offset: 0 }, _start) === 1 &&
+    compareBoundaryPointsPosition({ node, offset: nodeLength(node) }, _end) === -1
+  );
+}
+
+// https://dom.spec.whatwg.org/#partially-contained
+function isPartiallyContained(node, range) {
+  const { _start, _end } = range;
+  return (
+    (isInclusiveAncestor(node, _start.node) && !isInclusiveAncestor(node, _end.node)) ||
+    (!isInclusiveAncestor(node, _start.node) && isInclusiveAncestor(node, _end.node))
+  );
+}
+
+// https://dom.spec.whatwg.org/#concept-range-insert
+function insertNodeInRange(node, range) {
+  const { node: startNode, offset: startOffset } = range._start;
+
+  if (
+    startNode.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+    startNode.nodeType === NODE_TYPE.COMMENT_NODE ||
+    (startNode.nodeType === NODE_TYPE.TEXT_NODE && !domSymbolTree.parent(startNode)) ||
+    node === startNode
+  ) {
+    throw DOMException.create(node._globalObject, ["Invalid start node.", "HierarchyRequestError"]);
+  }
+
+  let referenceNode = startNode.nodeType === NODE_TYPE.TEXT_NODE ?
+    startNode :
+    domSymbolTree.childrenToArray(startNode)[startOffset] || null;
+  const parent = !referenceNode ?
+    startNode :
+    domSymbolTree.parent(referenceNode);
+
+  parent._preInsertValidity(node, referenceNode);
+
+  if (startNode.nodeType === NODE_TYPE.TEXT_NODE) {
+    referenceNode = startNode.splitText(startOffset);
+  }
+
+  if (node === referenceNode) {
+    referenceNode = domSymbolTree.nextSibling(referenceNode);
+  }
+
+  const nodeParent = domSymbolTree.parent(node);
+  if (nodeParent) {
+    nodeParent.removeChild(node);
+  }
+
+  let newOffset = !referenceNode ? nodeLength(parent) : domSymbolTree.index(referenceNode);
+  newOffset += node.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE ? nodeLength(node) : 1;
+
+  parent.insertBefore(node, referenceNode);
+
+  if (range.collapsed) {
+    range._setLiveRangeEnd(parent, newOffset);
+  }
+}
+
+// https://dom.spec.whatwg.org/#concept-range-clone
+function cloneRange(range) {
+  const { _start: originalStart, _end: originalEnd, _globalObject } = range;
+
+  const fragment = DocumentFragment.createImpl(_globalObject, [], {
+    ownerDocument: originalStart.node._ownerDocument
+  });
+
+  if (range.collapsed) {
+    return fragment;
+  }
+
+  if (
+    originalStart.node === originalEnd.node &&
+    (
+      originalStart.node.nodeType === NODE_TYPE.TEXT_NODE ||
+      originalStart.node.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      originalStart.node.nodeType === NODE_TYPE.COMMENT_NODE
+    )
+  ) {
+    const cloned = clone(originalStart.node);
+    cloned._data = cloned.substringData(originalStart.offset, originalEnd.offset - originalStart.offset);
+
+    fragment.appendChild(cloned);
+
+    return fragment;
+  }
+
+  let commonAncestor = originalStart.node;
+  while (!isInclusiveAncestor(commonAncestor, originalEnd.node)) {
+    commonAncestor = domSymbolTree.parent(commonAncestor);
+  }
+
+  let firstPartialContainedChild = null;
+  if (!isInclusiveAncestor(originalStart.node, originalEnd.node)) {
+    let candidate = domSymbolTree.firstChild(commonAncestor);
+    while (!firstPartialContainedChild) {
+      if (isPartiallyContained(candidate, range)) {
+        firstPartialContainedChild = candidate;
+      }
+
+      candidate = domSymbolTree.nextSibling(candidate);
+    }
+  }
+
+  let lastPartiallyContainedChild = null;
+  if (!isInclusiveAncestor(originalEnd.node, originalStart.node)) {
+    let candidate = domSymbolTree.lastChild(commonAncestor);
+    while (!lastPartiallyContainedChild) {
+      if (isPartiallyContained(candidate, range)) {
+        lastPartiallyContainedChild = candidate;
+      }
+
+      candidate = domSymbolTree.previousSibling(candidate);
+    }
+  }
+
+  const containedChildren = domSymbolTree.childrenToArray(commonAncestor)
+    .filter(node => isContained(node, range));
+
+  const hasDoctypeChildren = containedChildren.some(node => node.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE);
+  if (hasDoctypeChildren) {
+    throw DOMException.create(range._globalObject, ["Invalid document type element.", "HierarchyRequestError"]);
+  }
+
+  if (
+    firstPartialContainedChild !== null &&
+    (
+      firstPartialContainedChild.nodeType === NODE_TYPE.TEXT_NODE ||
+      firstPartialContainedChild.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      firstPartialContainedChild.nodeType === NODE_TYPE.COMMENT_NODE
+    )
+  ) {
+    const cloned = clone(originalStart.node);
+    cloned._data = cloned.substringData(originalStart.offset, nodeLength(originalStart.node) - originalStart.offset);
+
+    fragment.appendChild(cloned);
+  } else if (firstPartialContainedChild !== null) {
+    const cloned = clone(firstPartialContainedChild);
+    fragment.appendChild(cloned);
+
+    const subrange = Range.createImpl(_globalObject, [], {
+      start: { node: originalStart.node, offset: originalStart.offset },
+      end: { node: firstPartialContainedChild, offset: nodeLength(firstPartialContainedChild) }
+    });
+
+    const subfragment = cloneRange(subrange);
+    cloned.appendChild(subfragment);
+  }
+
+  for (const containedChild of containedChildren) {
+    const cloned = clone(containedChild, undefined, true);
+    fragment.appendChild(cloned);
+  }
+
+  if (
+    lastPartiallyContainedChild !== null &&
+    (
+      lastPartiallyContainedChild.nodeType === NODE_TYPE.TEXT_NODE ||
+      lastPartiallyContainedChild.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      lastPartiallyContainedChild.nodeType === NODE_TYPE.COMMENT_NODE
+    )
+  ) {
+    const cloned = clone(originalEnd.node);
+    cloned._data = cloned.substringData(0, originalEnd.offset);
+
+    fragment.appendChild(cloned);
+  } else if (lastPartiallyContainedChild !== null) {
+    const cloned = clone(lastPartiallyContainedChild);
+    fragment.appendChild(cloned);
+
+    const subrange = Range.createImpl(_globalObject, [], {
+      start: { node: lastPartiallyContainedChild, offset: 0 },
+      end: { node: originalEnd.node, offset: originalEnd.offset }
+    });
+
+    const subfragment = cloneRange(subrange);
+    cloned.appendChild(subfragment);
+  }
+
+  return fragment;
+}
+
+// https://dom.spec.whatwg.org/#concept-range-extract
+function extractRange(range) {
+  const { _start: originalStart, _end: originalEnd, _globalObject } = range;
+
+  const fragment = DocumentFragment.createImpl(_globalObject, [], {
+    ownerDocument: originalStart.node._ownerDocument
+  });
+
+  if (range.collapsed) {
+    return fragment;
+  }
+
+  if (
+    originalStart.node === originalEnd.node &&
+    (
+      originalStart.node.nodeType === NODE_TYPE.TEXT_NODE ||
+      originalStart.node.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      originalStart.node.nodeType === NODE_TYPE.COMMENT_NODE
+    )
+  ) {
+    const cloned = clone(originalStart.node);
+    cloned._data = cloned.substringData(originalStart.offset, originalEnd.offset - originalStart.offset);
+
+    fragment.appendChild(cloned);
+    originalStart.node.replaceData(originalStart.offset, originalEnd.offset - originalStart.offset, "");
+
+    return fragment;
+  }
+
+  let commonAncestor = originalStart.node;
+  while (!isInclusiveAncestor(commonAncestor, originalEnd.node)) {
+    commonAncestor = domSymbolTree.parent(commonAncestor);
+  }
+
+  let firstPartialContainedChild = null;
+  if (!isInclusiveAncestor(originalStart.node, originalEnd.node)) {
+    let candidate = domSymbolTree.firstChild(commonAncestor);
+    while (!firstPartialContainedChild) {
+      if (isPartiallyContained(candidate, range)) {
+        firstPartialContainedChild = candidate;
+      }
+
+      candidate = domSymbolTree.nextSibling(candidate);
+    }
+  }
+
+  let lastPartiallyContainedChild = null;
+  if (!isInclusiveAncestor(originalEnd.node, originalStart.node)) {
+    let candidate = domSymbolTree.lastChild(commonAncestor);
+    while (!lastPartiallyContainedChild) {
+      if (isPartiallyContained(candidate, range)) {
+        lastPartiallyContainedChild = candidate;
+      }
+
+      candidate = domSymbolTree.previousSibling(candidate);
+    }
+  }
+
+  const containedChildren = domSymbolTree.childrenToArray(commonAncestor)
+    .filter(node => isContained(node, range));
+
+  const hasDoctypeChildren = containedChildren.some(node => node.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE);
+  if (hasDoctypeChildren) {
+    throw DOMException.create(range._globalObject, ["Invalid document type element.", "HierarchyRequestError"]);
+  }
+
+  let newNode;
+  let newOffset;
+  if (isInclusiveAncestor(originalStart.node, originalEnd.node)) {
+    newNode = originalStart.node;
+    newOffset = originalStart.offset;
+  } else {
+    let referenceNode = originalStart.node;
+
+    while (
+      referenceNode &&
+      !isInclusiveAncestor(domSymbolTree.parent(referenceNode), originalEnd.node)
+    ) {
+      referenceNode = domSymbolTree.parent(referenceNode);
+    }
+
+    newNode = domSymbolTree.parent(referenceNode);
+    newOffset = domSymbolTree.index(referenceNode) + 1;
+  }
+
+  if (
+    firstPartialContainedChild !== null &&
+    (
+      firstPartialContainedChild.nodeType === NODE_TYPE.TEXT_NODE ||
+      firstPartialContainedChild.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      firstPartialContainedChild.nodeType === NODE_TYPE.COMMENT_NODE
+    )
+  ) {
+    const cloned = clone(originalStart.node);
+    cloned._data = cloned.substringData(originalStart.offset, nodeLength(originalStart.node) - originalStart.offset);
+
+    fragment.appendChild(cloned);
+
+    originalStart.node.replaceData(originalStart.offset, nodeLength(originalStart.node) - originalStart.offset, "");
+  } else if (firstPartialContainedChild !== null) {
+    const cloned = clone(firstPartialContainedChild);
+    fragment.appendChild(cloned);
+
+    const subrange = Range.createImpl(_globalObject, [], {
+      start: { node: originalStart.node, offset: originalStart.offset },
+      end: { node: firstPartialContainedChild, offset: nodeLength(firstPartialContainedChild) }
+    });
+
+    const subfragment = extractRange(subrange);
+    cloned.appendChild(subfragment);
+  }
+
+  for (const containedChild of containedChildren) {
+    fragment.appendChild(containedChild);
+  }
+
+  if (
+    lastPartiallyContainedChild !== null &&
+    (
+      lastPartiallyContainedChild.nodeType === NODE_TYPE.TEXT_NODE ||
+      lastPartiallyContainedChild.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE ||
+      lastPartiallyContainedChild.nodeType === NODE_TYPE.COMMENT_NODE
+    )
+  ) {
+    const cloned = clone(originalEnd.node);
+    cloned._data = cloned.substringData(0, originalEnd.offset);
+
+    fragment.appendChild(cloned);
+
+    originalEnd.node.replaceData(0, originalEnd.offset, "");
+  } else if (lastPartiallyContainedChild !== null) {
+    const cloned = clone(lastPartiallyContainedChild);
+    fragment.appendChild(cloned);
+
+    const subrange = Range.createImpl(_globalObject, [], {
+      start: { node: lastPartiallyContainedChild, offset: 0 },
+      end: { node: originalEnd.node, offset: originalEnd.offset }
+    });
+
+    const subfragment = extractRange(subrange);
+    cloned.appendChild(subfragment);
+  }
+
+  range._setLiveRangeStart(newNode, newOffset);
+  range._setLiveRangeEnd(newNode, newOffset);
+
+  return fragment;
+}
+
+module.exports = {
+  implementation: RangeImpl,
+
+  setBoundaryPointStart,
+  setBoundaryPointEnd
+};
diff --git a/lib/jsdom/living/range/StaticRange-impl.js b/lib/jsdom/living/range/StaticRange-impl.js
new file mode 100644
index 0000000..31bcc30
--- /dev/null
+++ b/lib/jsdom/living/range/StaticRange-impl.js
@@ -0,0 +1,39 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const NODE_TYPE = require("../node-type");
+
+const AbstractRangeImpl = require("./AbstractRange-impl").implementation;
+
+// https://dom.spec.whatwg.org/#staticrange
+class StaticRangeImpl extends AbstractRangeImpl {
+  // https://dom.spec.whatwg.org/#dom-staticrange-staticrange
+  constructor(globalObject, args) {
+    const { startContainer, startOffset, endContainer, endOffset } = args[0];
+
+    if (
+      startContainer.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE ||
+      startContainer.nodeType === NODE_TYPE.ATTRIBUTE_NODE ||
+      endContainer.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE ||
+      endContainer.nodeType === NODE_TYPE.ATTRIBUTE_NODE
+    ) {
+      throw DOMException.create(globalObject, ["The supplied node is incorrect.", "InvalidNodeTypeError"]);
+    }
+
+    super(globalObject, [], {
+      start: {
+        node: startContainer,
+        offset: startOffset
+      },
+      end: {
+        node: endContainer,
+        offset: endOffset
+      }
+    });
+  }
+}
+
+module.exports = {
+  implementation: StaticRangeImpl
+};
diff --git a/lib/jsdom/living/range/boundary-point.js b/lib/jsdom/living/range/boundary-point.js
new file mode 100644
index 0000000..a0eabdf
--- /dev/null
+++ b/lib/jsdom/living/range/boundary-point.js
@@ -0,0 +1,47 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { nodeRoot, isFollowing, isInclusiveAncestor } = require("../helpers/node");
+
+// Returns 0 if equal, +1 for after and -1 for before
+// https://dom.spec.whatwg.org/#concept-range-bp-after
+function compareBoundaryPointsPosition(bpA, bpB) {
+  const { node: nodeA, offset: offsetA } = bpA;
+  const { node: nodeB, offset: offsetB } = bpB;
+
+  if (nodeRoot(nodeA) !== nodeRoot(nodeB)) {
+    throw new Error(`Internal Error: Boundary points should have the same root!`);
+  }
+
+  if (nodeA === nodeB) {
+    if (offsetA === offsetB) {
+      return 0;
+    } else if (offsetA < offsetB) {
+      return -1;
+    }
+
+    return 1;
+  }
+
+  if (isFollowing(nodeA, nodeB)) {
+    return compareBoundaryPointsPosition(bpB, bpA) === -1 ? 1 : -1;
+  }
+
+  if (isInclusiveAncestor(nodeA, nodeB)) {
+    let child = nodeB;
+
+    while (domSymbolTree.parent(child) !== nodeA) {
+      child = domSymbolTree.parent(child);
+    }
+
+    if (domSymbolTree.index(child) < offsetA) {
+      return 1;
+    }
+  }
+
+  return -1;
+}
+
+module.exports = {
+  compareBoundaryPointsPosition
+};
diff --git a/lib/jsdom/living/selection/Selection-impl.js b/lib/jsdom/living/selection/Selection-impl.js
new file mode 100644
index 0000000..93f31b4
--- /dev/null
+++ b/lib/jsdom/living/selection/Selection-impl.js
@@ -0,0 +1,342 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const NODE_TYPE = require("../node-type");
+const { nodeLength, nodeRoot } = require("../helpers/node");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { compareBoundaryPointsPosition } = require("../range/boundary-point");
+
+const { setBoundaryPointStart, setBoundaryPointEnd } = require("../range/Range-impl");
+
+const Range = require("../generated/Range");
+const { implForWrapper } = require("../generated/utils");
+
+// https://w3c.github.io/selection-api/#dfn-direction
+const SELECTION_DIRECTION = {
+  FORWARDS: 1,
+  BACKWARDS: -1,
+  DIRECTIONLESS: 0
+};
+
+// https://w3c.github.io/selection-api/#dom-selection
+class SelectionImpl {
+  constructor(globalObject) {
+    this._range = null;
+    this._direction = SELECTION_DIRECTION.DIRECTIONLESS;
+
+    this._globalObject = globalObject;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-anchornode
+  get anchorNode() {
+    const anchor = this._anchor;
+    return anchor ? anchor.node : null;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-anchoroffset
+  get anchorOffset() {
+    const anchor = this._anchor;
+    return anchor ? anchor.offset : 0;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-focusnode
+  get focusNode() {
+    const focus = this._focus;
+    return focus ? focus.node : null;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-focusoffset
+  get focusOffset() {
+    const focus = this._focus;
+    return focus ? focus.offset : 0;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-iscollapsed
+  get isCollapsed() {
+    return this._range === null || this._range.collapsed;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-rangecount
+  get rangeCount() {
+    return this._isEmpty() ? 0 : 1;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-type
+  get type() {
+    if (this._isEmpty()) {
+      return "None";
+    } else if (this._range.collapsed) {
+      return "Caret";
+    }
+
+    return "Range";
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-getrangeat
+  getRangeAt(index) {
+    if (index !== 0 || this._isEmpty()) {
+      throw DOMException.create(this._globalObject, ["Invalid range index.", "IndexSizeError"]);
+    }
+
+    return this._range;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-addrange
+  addRange(range) {
+    if (range._root === implForWrapper(this._globalObject._document) && this.rangeCount === 0) {
+      this._associateRange(range);
+    }
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-removerange
+  removeRange(range) {
+    if (range !== this._range) {
+      throw DOMException.create(this._globalObject, ["Invalid range.", "NotFoundError"]);
+    }
+
+    this._associateRange(null);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-removeallranges
+  removeAllRanges() {
+    this._associateRange(null);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-empty
+  empty() {
+    this.removeAllRanges();
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-collapse
+  collapse(node, offset) {
+    if (node === null) {
+      this.removeAllRanges();
+      return;
+    }
+
+    if (node.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) {
+      throw DOMException.create(this._globalObject, [
+        "DocumentType Node can't be used as boundary point.",
+        "InvalidNodeTypeError"
+      ]);
+    }
+
+    if (offset > nodeLength(node)) {
+      throw DOMException.create(this._globalObject, ["Invalid range index.", "IndexSizeError"]);
+    }
+
+    if (nodeRoot(node) !== implForWrapper(this._globalObject._document)) {
+      return;
+    }
+
+    const newRange = Range.createImpl(this._globalObject, [], {
+      start: { node, offset: 0 },
+      end: { node, offset: 0 }
+    });
+
+    setBoundaryPointStart(newRange, node, offset);
+    setBoundaryPointEnd(newRange, node, offset);
+
+    this._associateRange(newRange);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-setposition
+  setPosition(node, offset) {
+    this.collapse(node, offset);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-collapsetostart
+  collapseToStart() {
+    if (this._isEmpty()) {
+      throw DOMException.create(this._globalObject, ["There is no selection to collapse.", "InvalidStateError"]);
+    }
+
+    const { node, offset } = this._range._start;
+    const newRange = Range.createImpl(this._globalObject, [], {
+      start: { node, offset },
+      end: { node, offset }
+    });
+
+    this._associateRange(newRange);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-collapsetoend
+  collapseToEnd() {
+    if (this._isEmpty()) {
+      throw DOMException.create(this._globalObject, ["There is no selection to collapse.", "InvalidStateError"]);
+    }
+
+    const { node, offset } = this._range._end;
+    const newRange = Range.createImpl(this._globalObject, [], {
+      start: { node, offset },
+      end: { node, offset }
+    });
+
+    this._associateRange(newRange);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-extend
+  extend(node, offset) {
+    if (nodeRoot(node) !== implForWrapper(this._globalObject._document)) {
+      return;
+    }
+
+    if (this._isEmpty()) {
+      throw DOMException.create(this._globalObject, ["There is no selection to extend.", "InvalidStateError"]);
+    }
+
+    const { _anchor: oldAnchor } = this;
+    const newFocus = { node, offset };
+
+    const newRange = Range.createImpl(this._globalObject, [], {
+      start: { node, offset: 0 },
+      end: { node, offset: 0 }
+    });
+
+    if (nodeRoot(node) !== this._range._root) {
+      setBoundaryPointStart(newRange, newFocus.node, newFocus.offset);
+      setBoundaryPointEnd(newRange, newFocus.node, newFocus.offset);
+    } else if (compareBoundaryPointsPosition(oldAnchor, newFocus) <= 0) {
+      setBoundaryPointStart(newRange, oldAnchor.node, oldAnchor.offset);
+      setBoundaryPointEnd(newRange, newFocus.node, newFocus.offset);
+    } else {
+      setBoundaryPointStart(newRange, newFocus.node, newFocus.offset);
+      setBoundaryPointEnd(newRange, oldAnchor.node, oldAnchor.offset);
+    }
+
+    this._associateRange(newRange);
+
+    this._direction = compareBoundaryPointsPosition(newFocus, oldAnchor) === -1 ?
+      SELECTION_DIRECTION.BACKWARDS :
+      SELECTION_DIRECTION.FORWARDS;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-setbaseandextent
+  setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset) {
+    if (anchorOffset > nodeLength(anchorNode) || focusOffset > nodeLength(focusNode)) {
+      throw DOMException.create(this._globalObject, ["Invalid anchor or focus offset.", "IndexSizeError"]);
+    }
+
+    const document = implForWrapper(this._globalObject._document);
+    if (document !== nodeRoot(anchorNode) || document !== nodeRoot(focusNode)) {
+      return;
+    }
+
+    const anchor = { node: anchorNode, offset: anchorOffset };
+    const focus = { node: focusNode, offset: focusOffset };
+
+    let newRange;
+    if (compareBoundaryPointsPosition(anchor, focus) === -1) {
+      newRange = Range.createImpl(this._globalObject, [], {
+        start: { node: anchor.node, offset: anchor.offset },
+        end: { node: focus.node, offset: focus.offset }
+      });
+    } else {
+      newRange = Range.createImpl(this._globalObject, [], {
+        start: { node: focus.node, offset: focus.offset },
+        end: { node: anchor.node, offset: anchor.offset }
+      });
+    }
+
+    this._associateRange(newRange);
+
+    this._direction = compareBoundaryPointsPosition(focus, anchor) === -1 ?
+      SELECTION_DIRECTION.BACKWARDS :
+      SELECTION_DIRECTION.FORWARDS;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-selectallchildren
+  selectAllChildren(node) {
+    if (node.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) {
+      throw DOMException.create(this._globalObject, [
+        "DocumentType Node can't be used as boundary point.",
+        "InvalidNodeTypeError"
+      ]);
+    }
+
+    const document = implForWrapper(this._globalObject._document);
+    if (document !== nodeRoot(node)) {
+      return;
+    }
+
+    const length = domSymbolTree.childrenCount(node);
+
+    const newRange = Range.createImpl(this._globalObject, [], {
+      start: { node, offset: 0 },
+      end: { node, offset: 0 }
+    });
+
+    setBoundaryPointStart(newRange, node, 0);
+    setBoundaryPointEnd(newRange, node, length);
+
+    this._associateRange(newRange);
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-deletefromdocument
+  deleteFromDocument() {
+    if (!this._isEmpty()) {
+      this._range.deleteContents();
+    }
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-containsnode
+  containsNode(node, allowPartialContainment) {
+    if (this._isEmpty() || nodeRoot(node) !== implForWrapper(this._globalObject._document)) {
+      return false;
+    }
+
+    const { _start, _end } = this._range;
+
+    const startIsBeforeNode = compareBoundaryPointsPosition(_start, { node, offset: 0 }) === -1;
+    const endIsAfterNode = compareBoundaryPointsPosition(_end, { node, offset: nodeLength(node) }) === 1;
+
+    return allowPartialContainment ?
+      startIsBeforeNode || endIsAfterNode :
+      startIsBeforeNode && endIsAfterNode;
+  }
+
+  // https://w3c.github.io/selection-api/#dom-selection-stringifier
+  toString() {
+    return this._range ? this._range.toString() : "";
+  }
+
+  // https://w3c.github.io/selection-api/#dfn-empty
+  _isEmpty() {
+    return this._range === null;
+  }
+
+  // https://w3c.github.io/selection-api/#dfn-anchor
+  get _anchor() {
+    if (!this._range) {
+      return null;
+    }
+
+    return this._direction === SELECTION_DIRECTION.FORWARDS ?
+      this._range._start :
+      this._range._end;
+  }
+
+  // https://w3c.github.io/selection-api/#dfn-focus
+  get _focus() {
+    if (!this._range) {
+      return null;
+    }
+
+    return this._direction === SELECTION_DIRECTION.FORWARDS ?
+      this._range._end :
+      this._range._start;
+  }
+
+  _associateRange(newRange) {
+    this._range = newRange;
+    this._direction = newRange === null ? SELECTION_DIRECTION.DIRECTIONLESS : SELECTION_DIRECTION.FORWARDS;
+
+    // TODO: Emit "selectionchange" event. At this time, there is currently no test in WPT covering this.
+    // https://w3c.github.io/selection-api/#selectionchange-event
+  }
+}
+
+module.exports = {
+  implementation: SelectionImpl
+};
diff --git a/lib/jsdom/living/svg/SVGAnimatedString-impl.js b/lib/jsdom/living/svg/SVGAnimatedString-impl.js
new file mode 100644
index 0000000..4751f64
--- /dev/null
+++ b/lib/jsdom/living/svg/SVGAnimatedString-impl.js
@@ -0,0 +1,38 @@
+"use strict";
+
+class SVGAnimatedStringImpl {
+  constructor(globalObject, args, privateData) {
+    this._element = privateData.element;
+    this._attribute = privateData.attribute;
+    this._attributeDeprecated = privateData.attributeDeprecated; // can be undefined
+    this._initialValue = privateData.initialValue; // can be undefined
+  }
+
+  get baseVal() {
+    if (!this._element.hasAttributeNS(null, this._attribute)) {
+      if (this._attributeDeprecated !== undefined && this._element.hasAttributeNS(null, this._attributeDeprecated)) {
+        return this._element.getAttributeNS(null, this._attributeDeprecated);
+      } else if (this._initialValue !== undefined) {
+        return this._initialValue;
+      }
+      return "";
+    }
+    return this._element.getAttributeNS(null, this._attribute);
+  }
+
+  get animVal() {
+    return this.baseVal;
+  }
+
+  set baseVal(base) {
+    if (!this._element.hasAttributeNS(null, this._attribute) &&
+        this._attributeDeprecated !== undefined &&
+        this._element.hasAttributeNS(null, this._attributeDeprecated)) {
+      this._element.setAttributeNS(null, this._attributeDeprecated, base);
+    } else {
+      this._element.setAttributeNS(null, this._attribute, base);
+    }
+  }
+}
+
+exports.implementation = SVGAnimatedStringImpl;
diff --git a/lib/jsdom/living/svg/SVGListBase.js b/lib/jsdom/living/svg/SVGListBase.js
new file mode 100644
index 0000000..247721d
--- /dev/null
+++ b/lib/jsdom/living/svg/SVGListBase.js
@@ -0,0 +1,195 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const idlUtils = require("../generated/utils");
+const { attach, detach } = require("../helpers/svg/basic-types");
+
+// https://svgwg.org/svg2-draft/types.html#ListInterfaces
+
+// Child classes must implement _reserialize()
+class List {
+  _initList({
+    element,
+    attribute,
+    readOnly = false
+  }) {
+    this._element = element;
+    this._attribute = attribute;
+    this._attributeRegistryEntry = element.constructor.attributeRegistry.get(attribute);
+    this._readOnly = readOnly;
+    this._list = [];
+    this._version = -1;
+  }
+
+  get _needsResync() {
+    return this._version < this._element._version;
+  }
+
+  _synchronize() {
+    if (!this._needsResync) {
+      return;
+    }
+    let value = [];
+    if (this._element.hasAttributeNS(null, this._attribute)) {
+      value = this._attributeRegistryEntry.getValue(this._element.getAttributeNS(null, this._attribute));
+    }
+    if (value.length === 0 && this._attributeRegistryEntry.initialValue !== undefined) {
+      value = this._attributeRegistryEntry.getValue(this._attributeRegistryEntry.initialValue);
+    }
+    // TODO: support non-DOMString lists.
+    this._list = value;
+    this._version = this._element._version;
+  }
+
+  _reserialize() {
+    const elements = this._list;
+    this._element.setAttributeNS(null, this._attribute, this._attributeRegistryEntry.serialize(elements));
+    // Prevent ping-ponging back and forth between _reserialize() and _synchronize().
+    this._version = this._element._version;
+  }
+
+  [idlUtils.supportsPropertyIndex](index) {
+    this._synchronize();
+    return index >= 0 && index < this.length;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    this._synchronize();
+    return this._list.keys();
+  }
+
+  get length() {
+    this._synchronize();
+    return this._list.length;
+  }
+
+  get numberOfItems() {
+    this._synchronize();
+    return this._list.length;
+  }
+
+  clear() {
+    this._synchronize();
+    if (this._readOnly) {
+      throw DOMException.create(this._globalObject, [
+        "Attempting to modify a read-only list",
+        "NoModificationAllowedError"
+      ]);
+    }
+    for (const item of this._list) {
+      detach(item);
+    }
+    this._list.length = 0;
+    this._reserialize();
+  }
+
+  initialize(newItem) {
+    this._synchronize();
+    if (this._readOnly) {
+      throw DOMException.create(this._globalObject, [
+        "Attempting to modify a read-only list",
+        "NoModificationAllowedError"
+      ]);
+    }
+    for (const item of this._list) {
+      detach(item);
+    }
+    this._list.length = 0;
+    // TODO: clone non-DOMString list elements.
+    attach(newItem, this);
+    this._list.push(newItem);
+    this._reserialize();
+  }
+
+  getItem(index) {
+    this._synchronize();
+    if (index >= this._list.length) {
+      throw DOMException.create(this._globalObject, [
+        `The index provided (${index}) is greater than or equal to the maximum bound (${this._list.length}).`,
+        "IndexSizeError"
+      ]);
+    }
+    return this._list[index];
+  }
+
+  insertItemBefore(newItem, index) {
+    this._synchronize();
+    if (this._readOnly) {
+      throw DOMException.create(this._globalObject, [
+        "Attempting to modify a read-only list",
+        "NoModificationAllowedError"
+      ]);
+    }
+    // TODO: clone non-DOMString list elements.
+    if (index > this._list.length) {
+      index = this._list.length;
+    }
+    this._list.splice(index, 0, newItem);
+    attach(newItem, this);
+    this._reserialize();
+    return newItem;
+  }
+
+  replaceItem(newItem, index) {
+    this._synchronize();
+    if (this._readOnly) {
+      throw DOMException.create(this._globalObject, [
+        "Attempting to modify a read-only list",
+        "NoModificationAllowedError"
+      ]);
+    }
+    if (index >= this._list.length) {
+      throw DOMException.create(this._globalObject, [
+        `The index provided (${index}) is greater than or equal to the maximum bound (${this._list.length}).`,
+        "IndexSizeError"
+      ]);
+    }
+    // TODO: clone non-DOMString list elements.
+    detach(this._list[index]);
+    this._list[index] = newItem;
+    attach(newItem, this);
+    this._reserialize();
+    return newItem;
+  }
+
+  removeItem(index) {
+    this._synchronize();
+    if (this._readOnly) {
+      throw DOMException.create(this._globalObject, [
+        "Attempting to modify a read-only list",
+        "NoModificationAllowedError"
+      ]);
+    }
+    if (index >= this._list.length) {
+      throw DOMException.create(this._globalObject, [
+        `The index provided (${index}) is greater than or equal to the maximum bound (${this._list.length}).`,
+        "IndexSizeError"
+      ]);
+    }
+    const item = this._list[index];
+    detach(item);
+    this._list.splice(index, 1);
+    this._reserialize();
+    return item;
+  }
+
+  appendItem(newItem) {
+    this._synchronize();
+    // TODO: clone non-DOMString list elements.
+    this._list.push(newItem);
+    attach(newItem, this);
+    this._reserialize();
+    return newItem;
+  }
+
+  [idlUtils.indexedSetNew](index, value) {
+    // Note: this will always throw a IndexSizeError.
+    this.replaceItem(value, index);
+  }
+
+  [idlUtils.indexedSetExisting](index, value) {
+    this.replaceItem(value, index);
+  }
+}
+
+module.exports = List;
diff --git a/lib/jsdom/living/svg/SVGNumber-impl.js b/lib/jsdom/living/svg/SVGNumber-impl.js
new file mode 100644
index 0000000..8a1ba9c
--- /dev/null
+++ b/lib/jsdom/living/svg/SVGNumber-impl.js
@@ -0,0 +1,48 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+
+class SVGNumberImpl {
+  constructor(globalObject, args, privateData) {
+    // Delegate to parent List object for (almost) everything related to reflection.
+    this._parentList = privateData.parentList;
+    this._value = 0;
+  }
+
+  get _readOnly() {
+    if (this._parentList !== undefined) {
+      return this._parentList._readOnly;
+    }
+    return false;
+  }
+
+  _synchronize() {
+    if (this._parentList !== undefined) {
+      this._parentList._synchronize();
+    }
+  }
+
+  _reserialize() {
+    if (this._parentList !== undefined) {
+      this._parentList._reserialize();
+    }
+  }
+
+  get value() {
+    this._synchronize();
+    return this._value;
+  }
+
+  set value(value) {
+    if (this._readOnly) {
+      throw DOMException.create(this._globalObject, [
+        "Attempting to modify a read-only SVGNumber",
+        "NoModificationAllowedError"
+      ]);
+    }
+    this._value = value;
+    this._reserialize();
+  }
+}
+
+exports.implementation = SVGNumberImpl;
diff --git a/lib/jsdom/living/svg/SVGStringList-impl.js b/lib/jsdom/living/svg/SVGStringList-impl.js
new file mode 100644
index 0000000..a745ea7
--- /dev/null
+++ b/lib/jsdom/living/svg/SVGStringList-impl.js
@@ -0,0 +1,16 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const SVGListBase = require("./SVGListBase");
+
+class SVGStringListImpl {
+  constructor(globalObject, args, privateData) {
+    this._globalObject = globalObject;
+
+    this._initList(privateData);
+  }
+}
+
+mixin(SVGStringListImpl.prototype, SVGListBase.prototype);
+
+exports.implementation = SVGStringListImpl;
diff --git a/lib/jsdom/living/traversal/NodeIterator-impl.js b/lib/jsdom/living/traversal/NodeIterator-impl.js
new file mode 100644
index 0000000..59bac54
--- /dev/null
+++ b/lib/jsdom/living/traversal/NodeIterator-impl.js
@@ -0,0 +1,125 @@
+"use strict";
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { filter, FILTER_ACCEPT } = require("./helpers");
+
+exports.implementation = class NodeIteratorImpl {
+  constructor(globalObject, args, privateData) {
+    this._active = false;
+    this.root = privateData.root;
+    this.whatToShow = privateData.whatToShow;
+    this.filter = privateData.filter;
+
+    this._referenceNode = this.root;
+    this._pointerBeforeReferenceNode = true;
+
+    // This is used to deactive the NodeIterator if there are too many working in a Document at the same time.
+    // Without weak references, a JS implementation of NodeIterator will leak, since we can't know when to clean it up.
+    // This ensures we force a clean up of those beyond some maximum (specified by the Document).
+    this._working = true;
+    this._workingNodeIteratorsMax = privateData.workingNodeIteratorsMax;
+
+    this._globalObject = globalObject;
+  }
+
+  get referenceNode() {
+    this._throwIfNotWorking();
+    return this._referenceNode;
+  }
+
+  get pointerBeforeReferenceNode() {
+    this._throwIfNotWorking();
+    return this._pointerBeforeReferenceNode;
+  }
+
+  nextNode() {
+    this._throwIfNotWorking();
+    return this._traverse("next");
+  }
+
+  previousNode() {
+    this._throwIfNotWorking();
+    return this._traverse("previous");
+  }
+
+  detach() {
+    // Intentionally do nothing, per spec.
+  }
+
+  // Called by Documents.
+  _preRemovingSteps(toBeRemovedNode) {
+    // Second clause is https://github.com/whatwg/dom/issues/496
+    if (!toBeRemovedNode.contains(this._referenceNode) || toBeRemovedNode === this.root) {
+      return;
+    }
+
+    if (this._pointerBeforeReferenceNode) {
+      let next = null;
+      let candidateForNext = domSymbolTree.following(toBeRemovedNode, { skipChildren: true });
+      while (candidateForNext !== null) {
+        if (this.root.contains(candidateForNext)) {
+          next = candidateForNext;
+          break;
+        }
+        candidateForNext = domSymbolTree.following(candidateForNext, { skipChildren: true });
+      }
+
+      if (next !== null) {
+        this._referenceNode = next;
+        return;
+      }
+
+      this._pointerBeforeReferenceNode = false;
+    }
+
+    const { previousSibling } = toBeRemovedNode;
+    this._referenceNode = previousSibling === null ?
+                          toBeRemovedNode.parentNode :
+                          domSymbolTree.lastInclusiveDescendant(toBeRemovedNode.previousSibling);
+  }
+
+  // Only called by getters and methods that are affected by the pre-removing steps
+  _throwIfNotWorking() {
+    if (!this._working) {
+      throw Error(`This NodeIterator is no longer working. More than ${this._workingNodeIteratorsMax} iterators are ` +
+        `being used concurrently. You can increase the 'concurrentNodeIterators' option to make this error go away.`);
+    }
+  }
+
+  _traverse(direction) {
+    let node = this._referenceNode;
+    let beforeNode = this._pointerBeforeReferenceNode;
+
+    while (true) {
+      if (direction === "next") {
+        if (!beforeNode) {
+          node = domSymbolTree.following(node, { root: this.root });
+
+          if (!node) {
+            return null;
+          }
+        }
+
+        beforeNode = false;
+      } else if (direction === "previous") {
+        if (beforeNode) {
+          node = domSymbolTree.preceding(node, { root: this.root });
+
+          if (!node) {
+            return null;
+          }
+        }
+
+        beforeNode = true;
+      }
+
+      const result = filter(this, node);
+      if (result === FILTER_ACCEPT) {
+        break;
+      }
+    }
+
+    this._referenceNode = node;
+    this._pointerBeforeReferenceNode = beforeNode;
+    return node;
+  }
+};
diff --git a/lib/jsdom/living/traversal/TreeWalker-impl.js b/lib/jsdom/living/traversal/TreeWalker-impl.js
new file mode 100644
index 0000000..a57b5f2
--- /dev/null
+++ b/lib/jsdom/living/traversal/TreeWalker-impl.js
@@ -0,0 +1,217 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const { filter, FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP } = require("./helpers");
+
+const FIRST = false;
+const LAST = true;
+const NEXT = false;
+const PREVIOUS = true;
+
+exports.implementation = class TreeWalkerImpl {
+  constructor(globalObject, args, privateData) {
+    this._active = false;
+    this.root = privateData.root;
+    this.currentNode = this.root;
+    this.whatToShow = privateData.whatToShow;
+    this.filter = privateData.filter;
+
+    this._globalObject = globalObject;
+  }
+
+  get currentNode() {
+    return this._currentNode;
+  }
+
+  set currentNode(node) {
+    if (node === null) {
+      throw DOMException.create(this._globalObject, ["Cannot set currentNode to null", "NotSupportedError"]);
+    }
+
+    this._currentNode = node;
+  }
+
+  parentNode() {
+    let node = this._currentNode;
+    while (node !== null && node !== this.root) {
+      node = node.parentNode;
+
+      if (node !== null && filter(this, node) === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+    }
+    return null;
+  }
+
+  firstChild() {
+    return this._traverseChildren(FIRST);
+  }
+
+  lastChild() {
+    return this._traverseChildren(LAST);
+  }
+
+  previousSibling() {
+    return this._traverseSiblings(PREVIOUS);
+  }
+
+  nextSibling() {
+    return this._traverseSiblings(NEXT);
+  }
+
+  previousNode() {
+    let node = this._currentNode;
+
+    while (node !== this.root) {
+      let sibling = node.previousSibling;
+
+      while (sibling !== null) {
+        node = sibling;
+        let result = filter(this, node);
+
+        while (result !== FILTER_REJECT && node.hasChildNodes()) {
+          node = node.lastChild;
+          result = filter(this, node);
+        }
+
+        if (result === FILTER_ACCEPT) {
+          return (this._currentNode = node);
+        }
+
+        sibling = node.previousSibling;
+      }
+
+      if (node === this.root || node.parentNode === null) {
+        return null;
+      }
+
+      node = node.parentNode;
+
+      if (filter(this, node) === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+    }
+
+    return null;
+  }
+
+  nextNode() {
+    let node = this._currentNode;
+    let result = FILTER_ACCEPT;
+
+    for (;;) {
+      while (result !== FILTER_REJECT && node.hasChildNodes()) {
+        node = node.firstChild;
+        result = filter(this, node);
+        if (result === FILTER_ACCEPT) {
+          return (this._currentNode = node);
+        }
+      }
+
+      do {
+        if (node === this.root) {
+          return null;
+        }
+
+        const sibling = node.nextSibling;
+
+        if (sibling !== null) {
+          node = sibling;
+          break;
+        }
+
+        node = node.parentNode;
+      } while (node !== null);
+
+      if (node === null) {
+        return null;
+      }
+
+      result = filter(this, node);
+
+      if (result === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+    }
+  }
+
+  _traverseChildren(type) {
+    let node = this._currentNode;
+    node = type === FIRST ? node.firstChild : node.lastChild;
+
+    if (node === null) {
+      return null;
+    }
+
+    main: for (;;) {
+      const result = filter(this, node);
+
+      if (result === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+
+      if (result === FILTER_SKIP) {
+        const child = type === FIRST ? node.firstChild : node.lastChild;
+
+        if (child !== null) {
+          node = child;
+          continue;
+        }
+      }
+
+      for (;;) {
+        const sibling = type === FIRST ? node.nextSibling : node.previousSibling;
+
+        if (sibling !== null) {
+          node = sibling;
+          continue main;
+        }
+
+        const parent = node.parentNode;
+
+        if (parent === null || parent === this.root || parent === this._currentNode) {
+          return null;
+        }
+
+        node = parent;
+      }
+    }
+  }
+
+  _traverseSiblings(type) {
+    let node = this._currentNode;
+
+    if (node === this.root) {
+      return null;
+    }
+
+    for (;;) {
+      let sibling = type === NEXT ? node.nextSibling : node.previousSibling;
+
+      while (sibling !== null) {
+        node = sibling;
+        const result = filter(this, node);
+
+        if (result === FILTER_ACCEPT) {
+          return (this._currentNode = node);
+        }
+
+        sibling = type === NEXT ? node.firstChild : node.lastChild;
+
+        if (result === FILTER_REJECT || sibling === null) {
+          sibling = type === NEXT ? node.nextSibling : node.previousSibling;
+        }
+      }
+
+      node = node.parentNode;
+
+      if (node === null || node === this.root) {
+        return null;
+      }
+
+      if (filter(this, node) === FILTER_ACCEPT) {
+        return null;
+      }
+    }
+  }
+};
diff --git a/lib/jsdom/living/traversal/helpers.js b/lib/jsdom/living/traversal/helpers.js
new file mode 100644
index 0000000..c2a5ea3
--- /dev/null
+++ b/lib/jsdom/living/traversal/helpers.js
@@ -0,0 +1,50 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const idlUtils = require("../generated/utils");
+const conversions = require("webidl-conversions");
+
+// TODO: Once NodeFilter is ported to IDL method, use those instead.
+exports.FILTER_ACCEPT = 1; // NodeFilter.FILTER_ACCEPT
+exports.FILTER_REJECT = 2; // NodeFilter.FILTER_REJECT
+exports.FILTER_SKIP = 3; // NodeFilter.FILTER_SKIP
+
+exports.filter = (nodeIteratorOrTreeWalkerImpl, nodeImpl) => {
+  if (nodeIteratorOrTreeWalkerImpl._active) {
+    throw DOMException.create(nodeIteratorOrTreeWalkerImpl._globalObject, [
+      "Recursive node filtering",
+      "InvalidStateError"
+    ]);
+  }
+
+  const n = nodeImpl.nodeType - 1;
+
+  if (!((1 << n) & nodeIteratorOrTreeWalkerImpl.whatToShow)) {
+    return exports.FILTER_SKIP;
+  }
+
+  // Saving in a variable is important so we don't accidentally call it as a method later.
+  const { filter } = nodeIteratorOrTreeWalkerImpl;
+
+  if (filter === null) {
+    return exports.FILTER_ACCEPT;
+  }
+
+  nodeIteratorOrTreeWalkerImpl._active = true;
+
+  let result;
+
+  // https://github.com/whatwg/dom/issues/494
+  try {
+    if (typeof filter === "function") {
+      result = filter(idlUtils.wrapperForImpl(nodeImpl));
+    } else {
+      result = filter.acceptNode(idlUtils.wrapperForImpl(nodeImpl));
+    }
+  } finally {
+    nodeIteratorOrTreeWalkerImpl._active = false;
+  }
+
+  result = conversions["unsigned short"](result);
+
+  return result;
+};
diff --git a/lib/jsdom/living/websockets/WebSocket-impl-browser.js b/lib/jsdom/living/websockets/WebSocket-impl-browser.js
new file mode 100644
index 0000000..6a2ab63
--- /dev/null
+++ b/lib/jsdom/living/websockets/WebSocket-impl-browser.js
@@ -0,0 +1,175 @@
+/* eslint-env browser */
+
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const { parseURL, serializeURL, serializeURLOrigin } = require("whatwg-url");
+
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+
+const idlUtils = require("../generated/utils");
+const Blob = require("../generated/Blob");
+const CloseEvent = require("../generated/CloseEvent");
+const MessageEvent = require("../generated/MessageEvent");
+
+const productions = {
+  // https://tools.ietf.org/html/rfc7230#section-3.2.6
+  token: /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/
+};
+
+// https://tools.ietf.org/html/rfc6455#section-4.3
+// See Sec-WebSocket-Protocol-Client, which is for the syntax of an entire header value. This function checks if a
+// single header conforms to the rules.
+function verifySecWebSocketProtocol(str) {
+  return productions.token.test(str);
+}
+
+const openSockets = new WeakMap();
+
+class WebSocketImpl extends EventTargetImpl {
+  constructor(constructorArgs, privateData) {
+    super([], privateData);
+    const { window } = privateData;
+    this._ownerDocument = idlUtils.implForWrapper(window._document);
+
+    const url = constructorArgs[0];
+    let protocols = constructorArgs[1] !== undefined ? constructorArgs[1] : [];
+
+    const urlRecord = parseURL(url);
+    if (urlRecord === null) {
+      throw DOMException.create(this._globalObject, [`The URL '${url}' is invalid.`, "SyntaxError"]);
+    }
+    if (urlRecord.scheme !== "ws" && urlRecord.scheme !== "wss") {
+      throw DOMException.create(this._globalObject, [
+        `The URL's scheme must be either 'ws' or 'wss'. '${urlRecord.scheme}' is not allowed.`,
+        "SyntaxError"
+      ]);
+    }
+    if (urlRecord.fragment !== null) {
+      throw DOMException.create(this._globalObject, [
+        `The URL contains a fragment identifier ('${urlRecord.fragment}'). Fragment identifiers ` +
+        "are not allowed in WebSocket URLs.",
+        "SyntaxError"
+      ]);
+    }
+
+    if (typeof protocols === "string") {
+      protocols = [protocols];
+    }
+    const protocolSet = new Set();
+    for (const protocol of protocols) {
+      if (!verifySecWebSocketProtocol(protocol)) {
+        throw DOMException.create(this._globalObject, [`The subprotocol '${protocol}' is invalid.`, "SyntaxError"]);
+      }
+      const lowered = protocol.toLowerCase();
+      if (protocolSet.has(lowered)) {
+        throw DOMException.create(this._globalObject, [
+          `The subprotocol '${protocol}' is duplicated.`,
+          "SyntaxError"
+        ]);
+      }
+      protocolSet.add(lowered);
+    }
+
+    this._urlRecord = urlRecord;
+    this.url = serializeURL(urlRecord);
+
+    this._ws = new WebSocket(this.url, protocols);
+
+    this._ws.onopen = () => {
+      fireAnEvent("open", this);
+    };
+    this._ws.onerror = () => {
+      fireAnEvent("error", this);
+    };
+    this._ws.onclose = event => {
+      fireAnEvent("close", this, CloseEvent, {
+        wasClean: event.wasClean,
+        code: event.code,
+        reason: event.reason
+      });
+    };
+    this._ws.onmessage = event => {
+      fireAnEvent("message", this, MessageEvent, {
+        data: event.data,
+        origin: serializeURLOrigin(this._urlRecord)
+      });
+    };
+
+    let openSocketsForWindow = openSockets.get(window._globalProxy);
+    if (openSocketsForWindow === undefined) {
+      openSocketsForWindow = new Set();
+      openSockets.set(window._globalProxy, openSocketsForWindow);
+    }
+    openSocketsForWindow.add(this);
+  }
+
+  // https://html.spec.whatwg.org/multipage/web-sockets.html#make-disappear
+  _makeDisappear() {
+    this._eventListeners = Object.create(null);
+    this._ws.close(1001);
+  }
+
+  static cleanUpWindow(window) {
+    const openSocketsForWindow = openSockets.get(window._globalProxy);
+    if (openSocketsForWindow !== undefined) {
+      for (const ws of openSocketsForWindow) {
+        ws._makeDisappear();
+      }
+    }
+  }
+
+  get readyState() {
+    return this._ws.readyState;
+  }
+
+  get bufferedAmount() {
+    return this._ws.bufferedAmount;
+  }
+
+  get extensions() {
+    return this._ws.extensions;
+  }
+
+  get protocol() {
+    return this._ws.protocol;
+  }
+
+  close(code = undefined, reason = undefined) {
+    if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) {
+      throw DOMException.create(this._globalObject, [
+        `The code must be either 1000, or between 3000 and 4999. ${code} is neither.`,
+        "InvalidAccessError"
+      ]);
+    }
+    if (reason !== undefined && Buffer.byteLength(reason, "utf8") > 123) {
+      throw DOMException.create(this._globalObject, [
+        "The message must not be greater than 123 bytes.",
+        "SyntaxError"
+      ]);
+    }
+    return this._ws.close(code, reason);
+  }
+
+  get binaryType() {
+    return this._ws.binaryType;
+  }
+
+  set binaryType(val) {
+    this._ws.binaryType = val;
+  }
+
+  send(data) {
+    if (Blob.isImpl(data)) {
+      data = data._buffer;
+    }
+    this._ws.send(data);
+  }
+}
+
+setupForSimpleEventAccessors(WebSocketImpl.prototype, ["open", "message", "error", "close"]);
+
+exports.implementation = WebSocketImpl;
diff --git a/lib/jsdom/living/websockets/WebSocket-impl.js b/lib/jsdom/living/websockets/WebSocket-impl.js
new file mode 100644
index 0000000..62dda89
--- /dev/null
+++ b/lib/jsdom/living/websockets/WebSocket-impl.js
@@ -0,0 +1,323 @@
+"use strict";
+
+const nodeURL = require("url");
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const { parseURL, serializeURL, serializeURLOrigin } = require("whatwg-url");
+const WebSocket = require("ws");
+
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+const { isArrayBuffer } = require("../generated/utils");
+const { copyToArrayBufferInNewRealm } = require("../helpers/binary-data");
+
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+
+const idlUtils = require("../generated/utils");
+const Blob = require("../generated/Blob");
+const CloseEvent = require("../generated/CloseEvent");
+const MessageEvent = require("../generated/MessageEvent");
+
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+
+const productions = {
+  // https://tools.ietf.org/html/rfc7230#section-3.2.6
+  token: /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/
+};
+
+const readyStateWSToDOM = [];
+readyStateWSToDOM[WebSocket.CONNECTING] = CONNECTING;
+readyStateWSToDOM[WebSocket.OPEN] = OPEN;
+readyStateWSToDOM[WebSocket.CLOSING] = CLOSING;
+readyStateWSToDOM[WebSocket.CLOSED] = CLOSED;
+
+// https://tools.ietf.org/html/rfc6455#section-4.3
+// See Sec-WebSocket-Protocol-Client, which is for the syntax of an entire header value. This function checks if a
+// single header conforms to the rules.
+function verifySecWebSocketProtocol(str) {
+  return productions.token.test(str);
+}
+
+class PromiseQueues extends WeakMap {
+  get(window) {
+    const cur = super.get(window);
+    return cur !== undefined ? cur : Promise.resolve();
+  }
+}
+
+const openSockets = new WeakMap();
+const openingQueues = new PromiseQueues();
+
+class WebSocketImpl extends EventTargetImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._ownerDocument = idlUtils.implForWrapper(globalObject._document);
+
+    const url = args[0];
+    let protocols = args[1] !== undefined ? args[1] : [];
+
+    const urlRecord = parseURL(url);
+    if (urlRecord === null) {
+      throw DOMException.create(this._globalObject, [`The URL '${url}' is invalid.`, "SyntaxError"]);
+    }
+    if (urlRecord.scheme !== "ws" && urlRecord.scheme !== "wss") {
+      throw DOMException.create(this._globalObject, [
+        `The URL's scheme must be either 'ws' or 'wss'. '${urlRecord.scheme}' is not allowed.`,
+        "SyntaxError"
+      ]);
+    }
+    if (urlRecord.fragment !== null) {
+      throw DOMException.create(this._globalObject, [
+        `The URL contains a fragment identifier ('${urlRecord.fragment}'). Fragment identifiers ` +
+        "are not allowed in WebSocket URLs.",
+        "SyntaxError"
+      ]);
+    }
+
+    if (typeof protocols === "string") {
+      protocols = [protocols];
+    }
+    const protocolSet = new Set();
+    for (const protocol of protocols) {
+      if (!verifySecWebSocketProtocol(protocol)) {
+        throw DOMException.create(this._globalObject, [`The subprotocol '${protocol}' is invalid.`, "SyntaxError"]);
+      }
+      const lowered = protocol.toLowerCase();
+      if (protocolSet.has(lowered)) {
+        throw DOMException.create(this._globalObject, [
+          `The subprotocol '${protocol}' is duplicated.`,
+          "SyntaxError"
+        ]);
+      }
+      protocolSet.add(lowered);
+    }
+
+    this._urlRecord = urlRecord;
+    this.url = serializeURL(urlRecord);
+    const nodeParsedURL = nodeURL.parse(this.url);
+    this.extensions = "";
+
+    this.binaryType = "blob";
+
+    this._ws = null;
+    // Used when this._ws has not been initialized yet.
+    this._readyState = CONNECTING;
+    this._requiredToFail = false;
+    this.bufferedAmount = 0;
+    this._sendQueue = [];
+
+    let openSocketsForWindow = openSockets.get(globalObject._globalProxy);
+    if (openSocketsForWindow === undefined) {
+      openSocketsForWindow = new Set();
+      openSockets.set(globalObject._globalProxy, openSocketsForWindow);
+    }
+    openSocketsForWindow.add(this);
+
+    openingQueues.set(this._ownerDocument, openingQueues.get(this._ownerDocument).then(() => new Promise(resolve => {
+      // close() called before _ws has been initialized.
+      if (this._requiredToFail) {
+        resolve();
+        this._readyState = CLOSED;
+        this._onConnectionClosed(1006, "");
+        return;
+      }
+
+      this._ws = new WebSocket(this.url, protocols, {
+        headers: {
+          "user-agent": globalObject.navigator.userAgent,
+          cookie: this._ownerDocument._cookieJar.getCookieStringSync(nodeParsedURL, { http: true }),
+          origin: globalObject._origin
+        },
+        rejectUnauthorized: this._ownerDocument._strictSSL
+      });
+      this._ws.once("open", () => {
+        resolve();
+        this._onConnectionEstablished();
+      });
+      this._ws.on("message", this._onMessageReceived.bind(this));
+      this._ws.once("close", (...closeArgs) => {
+        resolve();
+        this._onConnectionClosed(...closeArgs);
+      });
+      this._ws.once("upgrade", ({ headers }) => {
+        if (Array.isArray(headers["set-cookie"])) {
+          for (const cookie of headers["set-cookie"]) {
+            this._ownerDocument._cookieJar.setCookieSync(cookie, nodeParsedURL, { http: true, ignoreError: true });
+          }
+        } else if (headers["set-cookie"] !== undefined) {
+          this._ownerDocument._cookieJar.setCookieSync(
+            headers["set-cookie"], nodeParsedURL,
+            { http: true, ignoreError: true }
+          );
+        }
+      });
+      this._ws.once("error", () => {
+        // The exact error is passed into this callback, but it is ignored as we don't really care about it.
+        resolve();
+        this._requiredToFail = true;
+        // Do not emit an error here, as that will be handled in _onConnectionClosed. ws always emits a close event
+        // after errors.
+      });
+    })));
+  }
+
+  // https://html.spec.whatwg.org/multipage/web-sockets.html#make-disappear
+  _makeDisappear() {
+    this._eventListeners = Object.create(null);
+    this._close(1001);
+  }
+
+  static cleanUpWindow(window) {
+    const openSocketsForWindow = openSockets.get(window._globalProxy);
+    if (openSocketsForWindow !== undefined) {
+      for (const ws of openSocketsForWindow) {
+        ws._makeDisappear();
+      }
+    }
+  }
+
+  // https://html.spec.whatwg.org/multipage/web-sockets.html#feedback-from-the-protocol
+  _onConnectionEstablished() {
+    // readyState is a getter.
+    if (this._ws.extensions !== null) {
+      // Right now, ws only supports one extension, permessage-deflate, without any parameters. This algorithm may need
+      // to be more sophiscated as more extenions are supported.
+      this.extensions = Object.keys(this._ws.extensions).join(", ");
+    }
+    // protocol is a getter.
+    fireAnEvent("open", this);
+  }
+
+  _onMessageReceived(data) {
+    if (this.readyState !== OPEN) {
+      return;
+    }
+    let dataForEvent;
+    if (typeof data === "string") {
+      dataForEvent = data;
+    } else if (this.binaryType === "arraybuffer") {
+      if (isArrayBuffer(data)) {
+        dataForEvent = data;
+      } else if (Array.isArray(data)) {
+        dataForEvent = copyToArrayBufferInNewRealm(Buffer.concat(data), this._globalObject);
+      } else {
+        dataForEvent = copyToArrayBufferInNewRealm(data, this._globalObject);
+      }
+    } else { // this.binaryType === "blob"
+      if (!Array.isArray(data)) {
+        data = [data];
+      }
+      dataForEvent = Blob.create(this._globalObject, [data, { type: "" }]);
+    }
+    fireAnEvent("message", this, MessageEvent, {
+      data: dataForEvent,
+      origin: serializeURLOrigin(this._urlRecord)
+    });
+  }
+
+  _onConnectionClosed(code, reason) {
+    const openSocketsForWindow = openSockets.get(this._ownerDocument._defaultView);
+    openSocketsForWindow.delete(this);
+
+    const wasClean = !this._requiredToFail;
+    if (this._requiredToFail) {
+      fireAnEvent("error", this);
+    }
+    fireAnEvent("close", this, CloseEvent, {
+      wasClean,
+      code,
+      reason
+    });
+  }
+
+  get readyState() {
+    if (this._ws !== null) {
+      return readyStateWSToDOM[this._ws.readyState];
+    }
+    return this._readyState;
+  }
+
+  get protocol() {
+    if (this._ws === null) {
+      return "";
+    }
+    return this._ws.protocol;
+  }
+
+  close(code = undefined, reason = undefined) {
+    if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) {
+      throw DOMException.create(this._globalObject, [
+        `The code must be either 1000, or between 3000 and 4999. ${code} is neither.`,
+        "InvalidAccessError"
+      ]);
+    }
+    if (reason !== undefined && Buffer.byteLength(reason, "utf8") > 123) {
+      throw DOMException.create(this._globalObject, [
+        "The message must not be greater than 123 bytes.",
+        "SyntaxError"
+      ]);
+    }
+    this._close(code, reason);
+  }
+
+  _close(code = undefined, reason = undefined) {
+    if (this.readyState === CONNECTING) {
+      this._requiredToFail = true;
+      if (this._ws !== null) {
+        this._ws.terminate();
+      } else {
+        this._readyState = CLOSING;
+      }
+    } else if (this.readyState === OPEN) {
+      this._ws.close(code, reason);
+    }
+  }
+
+  send(data) {
+    if (this.readyState === CONNECTING) {
+      throw DOMException.create(this._globalObject, ["Still in CONNECTING state.", "InvalidStateError"]);
+    }
+    if (this.readyState !== OPEN) {
+      return;
+    }
+    if (Blob.isImpl(data)) {
+      data = data._buffer;
+    }
+    let length;
+    if (typeof data === "string") {
+      length = Buffer.byteLength(data, "utf8");
+    } else {
+      length = data.byteLength;
+    }
+    this.bufferedAmount += length;
+    this._sendQueue.push([data, length]);
+    this._scheduleSend();
+  }
+
+  _actuallySend() {
+    for (const [data, length] of this._sendQueue.splice(0)) {
+      this._ws.send(data, { binary: typeof data !== "string" }, () => {
+        this.bufferedAmount -= length;
+      });
+    }
+  }
+
+  _scheduleSend() {
+    if (this._dequeueScheduled) {
+      return;
+    }
+    this._dequeueScheduled = true;
+    process.nextTick(() => {
+      this._dequeueScheduled = false;
+      this._actuallySend();
+    });
+  }
+}
+
+setupForSimpleEventAccessors(WebSocketImpl.prototype, ["open", "message", "error", "close"]);
+
+exports.implementation = WebSocketImpl;
diff --git a/lib/jsdom/living/webstorage/Storage-impl.js b/lib/jsdom/living/webstorage/Storage-impl.js
new file mode 100644
index 0000000..7141682
--- /dev/null
+++ b/lib/jsdom/living/webstorage/Storage-impl.js
@@ -0,0 +1,102 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const StorageEvent = require("../generated/StorageEvent");
+const idlUtils = require("../generated/utils");
+const { fireAnEvent } = require("../helpers/events");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storage-interface
+class StorageImpl {
+  constructor(globalObject, args, privateData) {
+    const { associatedWindow, storageArea, url, type, storageQuota } = privateData;
+
+    this._associatedWindow = associatedWindow;
+    this._items = storageArea;
+    this._url = url;
+    this._type = type;
+    this._quota = storageQuota;
+
+    this._globalObject = globalObject;
+  }
+
+  _dispatchStorageEvent(key, oldValue, newValue) {
+    return this._associatedWindow._currentOriginData.windowsInSameOrigin
+      .filter(target => target !== this._associatedWindow)
+      .forEach(target => fireAnEvent("storage", target, StorageEvent, {
+        key,
+        oldValue,
+        newValue,
+        url: this._url,
+        storageArea: target["_" + this._type]
+      }));
+  }
+
+  get length() {
+    return this._items.size;
+  }
+
+  key(n) {
+    if (n >= this._items.size) {
+      return null;
+    }
+    return [...this._items.keys()][n];
+  }
+
+  getItem(key) {
+    if (this._items.has(key)) {
+      return this._items.get(key);
+    }
+    return null;
+  }
+
+  setItem(key, value) {
+    const oldValue = this._items.get(key) || null;
+
+    if (oldValue === value) {
+      return;
+    }
+
+    // Concatenate all keys and values to measure their length against the quota
+    let itemsTotalLength = key.length + value.length;
+    for (const [curKey, curValue] of this._items) {
+      // If the key already exists, skip it as it will be set to the new value instead
+      if (key !== curKey) {
+        itemsTotalLength += curKey.length + curValue.length;
+      }
+    }
+    if (itemsTotalLength > this._quota) {
+      throw DOMException.create(this._globalObject, [
+        `The ${this._quota}-code unit storage quota has been exceeded.`,
+        "QuotaExceededError"
+      ]);
+    }
+
+    setTimeout(this._dispatchStorageEvent.bind(this), 0, key, oldValue, value);
+
+    this._items.set(key, value);
+  }
+
+  removeItem(key) {
+    if (this._items.has(key)) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, key, this._items.get(key), null);
+
+      this._items.delete(key);
+    }
+  }
+
+  clear() {
+    if (this._items.size > 0) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, null, null, null);
+
+      this._items.clear();
+    }
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    return this._items.keys();
+  }
+}
+
+module.exports = {
+  implementation: StorageImpl
+};
diff --git a/lib/jsdom/living/window/BarProp-impl.js b/lib/jsdom/living/window/BarProp-impl.js
new file mode 100644
index 0000000..ae81b81
--- /dev/null
+++ b/lib/jsdom/living/window/BarProp-impl.js
@@ -0,0 +1,10 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/window-object.html#browser-interface-elements
+class BarPropImpl {}
+
+// Since many BarProps do not apply to modern browsers,
+// returning true in all cases seems to be common practice.
+BarPropImpl.prototype.visible = true;
+
+exports.implementation = BarPropImpl;
diff --git a/lib/jsdom/living/window/External-impl.js b/lib/jsdom/living/window/External-impl.js
new file mode 100644
index 0000000..645d97c
--- /dev/null
+++ b/lib/jsdom/living/window/External-impl.js
@@ -0,0 +1,9 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/obsolete.html#dom-external
+exports.implementation = class ExternalImpl {
+  // The AddSearchProvider() and IsSearchProviderInstalled() methods must do nothing
+  AddSearchProvider() {}
+
+  IsSearchProviderInstalled() {}
+};
diff --git a/lib/jsdom/living/window/History-impl.js b/lib/jsdom/living/window/History-impl.js
new file mode 100644
index 0000000..f8e764a
--- /dev/null
+++ b/lib/jsdom/living/window/History-impl.js
@@ -0,0 +1,134 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const { documentBaseURLSerialized, parseURLToResultingURLRecord } = require("../helpers/document-base-url.js");
+
+// https://html.spec.whatwg.org/#history-3
+exports.implementation = class HistoryImpl {
+  constructor(globalObject, args, privateData) {
+    this._window = privateData.window;
+    this._document = privateData.document;
+    this._actAsIfLocationReloadCalled = privateData.actAsIfLocationReloadCalled;
+    this._state = null;
+
+    this._globalObject = globalObject;
+  }
+
+  _guardAgainstInactiveDocuments() {
+    if (!this._window) {
+      throw DOMException.create(this._globalObject, [
+        "History object is associated with a document that is not fully active.",
+        "SecurityError"
+      ]);
+    }
+  }
+
+  get length() {
+    this._guardAgainstInactiveDocuments();
+
+    return this._window._sessionHistory.length;
+  }
+
+  get state() {
+    this._guardAgainstInactiveDocuments();
+
+    return this._state;
+  }
+
+  go(delta) {
+    this._guardAgainstInactiveDocuments();
+
+    if (delta === 0) {
+      // When the go(delta) method is invoked, if delta is zero, the user agent must act as
+      // if the location.reload() method was called instead.
+      this._actAsIfLocationReloadCalled();
+    } else {
+      // Otherwise, the user agent must traverse the history by a delta whose value is delta
+      this._window._sessionHistory.traverseByDelta(delta);
+    }
+  }
+
+  back() {
+    this.go(-1);
+  }
+
+  forward() {
+    this.go(+1);
+  }
+
+  pushState(data, title, url) {
+    this._sharedPushAndReplaceState(data, title, url, "pushState");
+  }
+  replaceState(data, title, url) {
+    this._sharedPushAndReplaceState(data, title, url, "replaceState");
+  }
+
+  // https://html.spec.whatwg.org/#dom-history-pushstate
+  _sharedPushAndReplaceState(data, title, url, methodName) {
+    this._guardAgainstInactiveDocuments();
+
+    // TODO structured clone data
+
+    let newURL;
+    if (url !== null) {
+      // Not implemented: use of entry settings object's API base URL. Instead we just use the document base URL. The
+      // difference matters in the case of cross-frame calls.
+      newURL = parseURLToResultingURLRecord(url, this._document);
+
+      if (newURL === null) {
+        throw DOMException.create(this._globalObject, [
+          `Could not parse url argument "${url}" to ${methodName} against base URL ` +
+          `"${documentBaseURLSerialized(this._document)}".`,
+          "SecurityError"
+        ]);
+      }
+
+      if (newURL.scheme !== this._document._URL.scheme ||
+          newURL.username !== this._document._URL.username ||
+          newURL.password !== this._document._URL.password ||
+          newURL.host !== this._document._URL.host ||
+          newURL.port !== this._document._URL.port ||
+          newURL.cannotBeABaseURL !== this._document._URL.cannotBeABaseURL) {
+        throw DOMException.create(this._globalObject, [
+          `${methodName} cannot update history to a URL which differs in components other than in ` +
+          `path, query, or fragment.`,
+          "SecurityError"
+        ]);
+      }
+
+      // Not implemented: origin check (seems to only apply to documents with weird origins, e.g. sandboxed ones)
+    } else {
+      newURL = this._window._sessionHistory.currentEntry.url;
+    }
+
+    if (methodName === "pushState") {
+      this._window._sessionHistory.removeAllEntriesAfterCurrentEntry();
+
+      this._window._sessionHistory.clearHistoryTraversalTasks();
+
+      const newEntry = {
+        document: this._document,
+        stateObject: data,
+        title,
+        url: newURL
+      };
+      this._window._sessionHistory.addEntryAfterCurrentEntry(newEntry);
+      this._window._sessionHistory.updateCurrentEntry(newEntry);
+    } else {
+      const { currentEntry } = this._window._sessionHistory;
+      currentEntry.stateObject = data;
+      currentEntry.title = title;
+      currentEntry.url = newURL;
+    }
+
+    // TODO: If the current entry in the session history represents a non-GET request
+    // (e.g. it was the result of a POST submission) then update it to instead represent
+    // a GET request.
+
+    this._document._URL = newURL;
+
+    // arguably it's a bit odd that the state and latestEntry do not belong to the SessionHistory
+    // but the spec gives them to "History" and "Document" respecively.
+    this._state = data; // TODO clone again!! O_o
+    this._document._latestEntry = this._window._sessionHistory.currentEntry;
+  }
+};
diff --git a/lib/jsdom/living/window/History.webidl b/lib/jsdom/living/window/History.webidl
new file mode 100644
index 0000000..8df4f5c
--- /dev/null
+++ b/lib/jsdom/living/window/History.webidl
@@ -0,0 +1,14 @@
+enum ScrollRestoration { "auto", "manual" };
+
+[Exposed=Window]
+interface History {
+//  readonly attribute unsigned long index;
+  readonly attribute unsigned long length;
+//  attribute ScrollRestoration scrollRestoration;
+  readonly attribute any state;
+  void go(optional long delta = 0);
+  void back();
+  void forward();
+  void pushState(any data, DOMString title, optional USVString? url = null);
+  void replaceState(any data, DOMString title, optional USVString? url = null);
+};
diff --git a/lib/jsdom/living/window/Location-impl.js b/lib/jsdom/living/window/Location-impl.js
new file mode 100644
index 0000000..c5b8ce3
--- /dev/null
+++ b/lib/jsdom/living/window/Location-impl.js
@@ -0,0 +1,238 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { documentBaseURL, parseURLToResultingURLRecord } = require("../helpers/document-base-url");
+const { navigate } = require("./navigation");
+
+// Not implemented: use of entry settings object's API base URL in href setter, assign, and replace. Instead we just
+// use the document base URL. The difference matters in the case of cross-frame calls.
+
+exports.implementation = class LocationImpl {
+  constructor(globalObject, args, privateData) {
+    this._relevantDocument = privateData.relevantDocument;
+    this.url = null;
+
+    this._globalObject = globalObject;
+  }
+
+  get _url() {
+    return this._relevantDocument._URL;
+  }
+
+  _locationObjectSetterNavigate(url) {
+    // Not implemented: extra steps here to determine replacement flag.
+
+    return this._locationObjectNavigate(url);
+  }
+
+  _locationObjectNavigate(url, { replacement = false } = {}) {
+    // Not implemented: the setup for calling navigate, which doesn't apply to our stub navigate anyway.
+
+    navigate(this._relevantDocument._defaultView, url, { replacement, exceptionsEnabled: true });
+  }
+
+  toString() {
+    return this.href;
+  }
+
+  get href() {
+    return whatwgURL.serializeURL(this._url);
+  }
+  set href(v) {
+    const newURL = whatwgURL.parseURL(v, { baseURL: documentBaseURL(this._relevantDocument) });
+    if (newURL === null) {
+      throw new TypeError(`Could not parse "${v}" as a URL`);
+    }
+
+    this._locationObjectSetterNavigate(newURL);
+  }
+
+  get origin() {
+    return whatwgURL.serializeURLOrigin(this._url);
+  }
+
+  get protocol() {
+    return this._url.scheme + ":";
+  }
+  set protocol(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    const possibleFailure = whatwgURL.basicURLParse(v + ":", { url: copyURL, stateOverride: "scheme start" });
+    if (possibleFailure === null) {
+      throw new TypeError(`Could not parse the URL after setting the procol to "${v}"`);
+    }
+
+    if (copyURL.scheme !== "http" && copyURL.scheme !== "https") {
+      return;
+    }
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get host() {
+    const url = this._url;
+
+    if (url.host === null) {
+      return "";
+    }
+    if (url.port === null) {
+      return whatwgURL.serializeHost(url.host);
+    }
+
+    return whatwgURL.serializeHost(url.host) + ":" + whatwgURL.serializeInteger(url.port);
+  }
+  set host(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    if (copyURL.cannotBeABaseURL) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "host" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get hostname() {
+    if (this._url.host === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeHost(this._url.host);
+  }
+  set hostname(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    if (copyURL.cannotBeABaseURL) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "hostname" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get port() {
+    if (this._url.port === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeInteger(this._url.port);
+  }
+  set port(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    if (copyURL.host === null || copyURL.cannotBeABaseURL || copyURL.scheme === "file") {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "port" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get pathname() {
+    const url = this._url;
+
+    if (url.cannotBeABaseURL) {
+      return url.path[0];
+    }
+
+    return "/" + url.path.join("/");
+  }
+  set pathname(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    if (copyURL.cannotBeABaseURL) {
+      return;
+    }
+
+    copyURL.path = [];
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "path start" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get search() {
+    if (this._url.query === null || this._url.query === "") {
+      return "";
+    }
+
+    return "?" + this._url.query;
+  }
+  set search(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    if (v === "") {
+      copyURL.query = null;
+    } else {
+      const input = v[0] === "?" ? v.substring(1) : v;
+      copyURL.query = "";
+      whatwgURL.basicURLParse(input, {
+        url: copyURL,
+        stateOverride: "query",
+        encodingOverride: this._relevantDocument.charset
+      });
+    }
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get hash() {
+    if (this._url.fragment === null || this._url.fragment === "") {
+      return "";
+    }
+
+    return "#" + this._url.fragment;
+  }
+  set hash(v) {
+    const copyURL = Object.assign({}, this._url);
+
+    if (copyURL.scheme === "javascript") {
+      return;
+    }
+
+    if (v === "") {
+      copyURL.fragment = null;
+    } else {
+      const input = v[0] === "#" ? v.substring(1) : v;
+      copyURL.fragment = "";
+      whatwgURL.basicURLParse(input, { url: copyURL, stateOverride: "fragment" });
+    }
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  assign(url) {
+    // Should be entry settings object; oh well
+    const parsedURL = parseURLToResultingURLRecord(url, this._relevantDocument);
+
+    if (parsedURL === null) {
+      throw DOMException.create(this._globalObject, [
+        `Could not resolve the given string "${url}" relative to the base URL "${this._relevantDocument.URL}"`,
+        "SyntaxError"
+      ]);
+    }
+
+    this._locationObjectNavigate(parsedURL);
+  }
+
+  replace(url) {
+    // Should be entry settings object; oh well
+    const parsedURL = parseURLToResultingURLRecord(url, this._relevantDocument);
+
+    if (parsedURL === null) {
+      throw DOMException.create(this._globalObject, [
+        `Could not resolve the given string "${url}" relative to the base URL "${this._relevantDocument.URL}"`,
+        "SyntaxError"
+      ]);
+    }
+
+    this._locationObjectNavigate(parsedURL, { replacement: true });
+  }
+
+  reload() {
+    const flags = { replace: true, reloadTriggered: true, exceptionsEnabled: true };
+    navigate(this._relevantDocument._defaultView, this._url, flags);
+  }
+};
diff --git a/lib/jsdom/living/window/Screen-impl.js b/lib/jsdom/living/window/Screen-impl.js
new file mode 100644
index 0000000..4f99c41
--- /dev/null
+++ b/lib/jsdom/living/window/Screen-impl.js
@@ -0,0 +1,13 @@
+"use strict";
+
+// https://drafts.csswg.org/cssom-view-1/#the-screen-interface
+class ScreenImpl {}
+
+ScreenImpl.prototype.availWidth = 0;
+ScreenImpl.prototype.availHeight = 0;
+ScreenImpl.prototype.width = 0;
+ScreenImpl.prototype.height = 0;
+ScreenImpl.prototype.colorDepth = 24;
+ScreenImpl.prototype.pixelDepth = 24;
+
+exports.implementation = ScreenImpl;
diff --git a/lib/jsdom/living/window/SessionHistory.js b/lib/jsdom/living/window/SessionHistory.js
new file mode 100644
index 0000000..bcac766
--- /dev/null
+++ b/lib/jsdom/living/window/SessionHistory.js
@@ -0,0 +1,164 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const HashChangeEvent = require("../generated/HashChangeEvent.js");
+const PopStateEvent = require("../generated/PopStateEvent.js");
+const notImplemented = require("../../browser/not-implemented.js");
+const idlUtils = require("../generated/utils.js");
+const { fireAnEvent } = require("../helpers/events");
+
+// https://html.spec.whatwg.org/#session-history
+class SessionHistory {
+  constructor(initialEntry, window) {
+    this._window = window;
+    this._windowImpl = idlUtils.implForWrapper(window);
+    this._historyTraversalQueue = new Set();
+    this._entries = [initialEntry];
+    this._currentIndex = 0;
+  }
+
+  _queueHistoryTraversalTask(fn) {
+    const timeoutId = this._window.setTimeout(() => {
+      this._historyTraversalQueue.delete(timeoutId);
+      fn();
+    }, 0);
+
+    this._historyTraversalQueue.add(timeoutId);
+  }
+
+  clearHistoryTraversalTasks() {
+    for (const timeoutId of this._historyTraversalQueue) {
+      this._window.clearTimeout(timeoutId);
+    }
+    this._historyTraversalQueue.clear();
+  }
+
+  get length() {
+    return this._entries.length;
+  }
+
+  get currentEntry() {
+    return this._entries[this._currentIndex];
+  }
+
+  // https://html.spec.whatwg.org/#dom-history-pushstate
+  removeAllEntriesAfterCurrentEntry() {
+    this._entries.splice(this._currentIndex + 1, Infinity);
+  }
+
+  // https://html.spec.whatwg.org/#traverse-the-history-by-a-delta
+  traverseByDelta(delta) {
+    this._queueHistoryTraversalTask(() => {
+      const newIndex = this._currentIndex + delta;
+      if (newIndex < 0 || newIndex >= this.length) {
+        return;
+      }
+
+      const specifiedEntry = this._entries[newIndex];
+
+      // Not implemented: unload a document guard
+
+      // Not clear that this should be queued. html/browsers/history/the-history-interface/004.html can be fixed
+      // by removing the queue, but doing so breaks some tests in history.js that also pass in browsers.
+      this._queueHistoryTraversalTask(() => {
+        // If there is an ongoing attempt to navigate specified browsing context that has not yet matured,
+        // then cancel that attempt to navigate the browsing context.
+
+        // Doing this seems to break tests involving navigating via push/pop state and via fragments. I think this
+        // is because these navigations should already count as having "matured" because the document is not changing.
+
+        // this.clearHistoryTraversalTasks();
+
+        if (specifiedEntry.document !== this.currentEntry.document) {
+          // TODO: unload the active document with the recycle parameter set to false
+          notImplemented("Traversing history in a way that would change the window", this._window);
+        }
+        this.traverseHistory(specifiedEntry);
+      });
+    });
+  }
+
+  // https://html.spec.whatwg.org/#traverse-the-history
+  traverseHistory(specifiedEntry, flags = {}) {
+    if (!specifiedEntry.document) {
+      // If entry no longer holds a Document object, then navigate the browsing context to entry's URL
+      // to perform an entry update of entry, and abort these steps
+      notImplemented("Traversing the history to an entry that no longer holds a Document object", this._window);
+    }
+    // Not spec compliant, just minimal. Lots of missing steps.
+
+    const nonBlockingEvents = Boolean(flags.nonBlockingEvents);
+
+    const document = idlUtils.implForWrapper(this._window._document);
+
+    const { currentEntry } = this;
+
+    // If the current entry's title was not set by the pushState() or replaceState() methods, then set its title
+    // to the value returned by the document.title IDL attribute.
+    if (currentEntry.title === undefined) {
+      currentEntry.title = document.title;
+    }
+
+
+    if (specifiedEntry.document !== currentEntry.document) {
+      // If entry has a different Document object than the current entry, then...
+      notImplemented("Traversing the history to an entry with a different Document", this._window);
+    }
+
+    document._URL = specifiedEntry.url;
+
+    const hashChanged =
+      specifiedEntry.url.fragment !== currentEntry.url.fragment && specifiedEntry.document === currentEntry.document;
+    let oldURL;
+    let newURL;
+    if (hashChanged) {
+      oldURL = currentEntry.url;
+      newURL = specifiedEntry.url;
+    }
+
+    if (flags.replacement) {
+      // If the traversal was initiated with replacement enabled, remove the entry immediately before the
+      // specified entry in the session history.
+      this._entries.splice(this._entries.indexOf(specifiedEntry) - 1, 1);
+    }
+
+    this.updateCurrentEntry(specifiedEntry);
+
+    const state = specifiedEntry.stateObject; // TODO structured clone
+
+    // arguably it's a bit odd that the state and latestEntry do not belong to the SessionHistory
+    // but the spec gives them to "History" and "Document" respecively.
+    document._history._state = state;
+    const stateChanged = specifiedEntry.document._latestEntry !== specifiedEntry;
+    specifiedEntry.document._latestEntry = specifiedEntry;
+
+    const fireEvents = () => this._fireEvents(stateChanged, hashChanged, state, oldURL, newURL);
+
+    if (nonBlockingEvents) {
+      this._window.setTimeout(fireEvents, 0);
+    } else {
+      fireEvents();
+    }
+  }
+
+  _fireEvents(stateChanged, hashChanged, state, oldURL, newURL) {
+    if (stateChanged) {
+      fireAnEvent("popstate", this._windowImpl, PopStateEvent, { state });
+    }
+
+    if (hashChanged) {
+      fireAnEvent("hashchange", this._windowImpl, HashChangeEvent, {
+        oldURL: whatwgURL.serializeURL(oldURL),
+        newURL: whatwgURL.serializeURL(newURL)
+      });
+    }
+  }
+
+  addEntryAfterCurrentEntry(entry) {
+    this._entries.splice(this._currentIndex + 1, 0, entry);
+  }
+
+  updateCurrentEntry(entry) {
+    this._currentIndex = this._entries.indexOf(entry);
+  }
+}
+module.exports = SessionHistory;
diff --git a/lib/jsdom/living/window/navigation.js b/lib/jsdom/living/window/navigation.js
new file mode 100644
index 0000000..b051f24
--- /dev/null
+++ b/lib/jsdom/living/window/navigation.js
@@ -0,0 +1,84 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const notImplemented = require("../../browser/not-implemented.js");
+const reportException = require("../helpers/runtime-script-errors.js");
+const idlUtils = require("../generated/utils.js");
+
+exports.evaluateJavaScriptURL = (window, urlRecord) => {
+  const urlString = whatwgURL.serializeURL(urlRecord);
+  const scriptSource = whatwgURL.percentDecode(Buffer.from(urlString)).toString();
+  if (window._runScripts === "dangerously") {
+    try {
+      return window.eval(scriptSource);
+    } catch (e) {
+      reportException(window, e, urlString);
+    }
+  }
+  return undefined;
+};
+
+// https://html.spec.whatwg.org/#navigating-across-documents
+exports.navigate = (window, newURL, flags) => {
+  // This is NOT a spec-compliant implementation of navigation in any way. It implements a few selective steps that
+  // are nice for jsdom users, regarding hash changes and JavaScript URLs. Full navigation support is being worked on
+  // and will likely require some additional hooks to be implemented.
+  if (!window._document) {
+    return;
+  }
+
+  const document = idlUtils.implForWrapper(window._document);
+  const currentURL = document._URL;
+
+  if (!flags.reloadTriggered && urlEquals(currentURL, newURL, { excludeFragments: true })) {
+    if (newURL.fragment !== currentURL.fragment) {
+      navigateToFragment(window, newURL, flags);
+    }
+    return;
+  }
+
+  // NOT IMPLEMENTED: Prompt to unload the active document of browsingContext.
+
+  // NOT IMPLEMENTED: form submission algorithm
+  // const navigationType = 'other';
+
+  // NOT IMPLEMENTED: if resource is a response...
+  if (newURL.scheme === "javascript") {
+    setTimeout(() => {
+      const result = exports.evaluateJavaScriptURL(window, newURL);
+      if (typeof result === "string") {
+        notImplemented("string results from 'javascript:' URLs", window);
+      }
+    }, 0);
+    return;
+  }
+  navigateFetch(window);
+};
+
+// https://html.spec.whatwg.org/#scroll-to-fragid
+function navigateToFragment(window, newURL, flags) {
+  const document = idlUtils.implForWrapper(window._document);
+
+  window._sessionHistory.clearHistoryTraversalTasks();
+
+  if (!flags.replacement) {
+    // handling replacement=true here deviates from spec, but matches real browser behaviour
+    // see https://github.com/whatwg/html/issues/2796 for spec bug
+    window._sessionHistory.removeAllEntriesAfterCurrentEntry();
+  }
+  const newEntry = { document, url: newURL };
+  window._sessionHistory.addEntryAfterCurrentEntry(newEntry);
+  window._sessionHistory.traverseHistory(newEntry, { nonBlockingEvents: true, replacement: flags.replacement });
+}
+
+// https://html.spec.whatwg.org/#process-a-navigate-fetch
+function navigateFetch(window) {
+  // TODO:
+  notImplemented("navigation (except hash changes)", window);
+}
+
+// https://url.spec.whatwg.org/#concept-url-equals
+function urlEquals(a, b, flags) {
+  const serializedA = whatwgURL.serializeURL(a, flags.excludeFragments);
+  const serializedB = whatwgURL.serializeURL(b, flags.excludeFragments);
+  return serializedA === serializedB;
+}
diff --git a/lib/jsdom/living/xhr/FormData-impl.js b/lib/jsdom/living/xhr/FormData-impl.js
new file mode 100644
index 0000000..bfcabf6
--- /dev/null
+++ b/lib/jsdom/living/xhr/FormData-impl.js
@@ -0,0 +1,176 @@
+"use strict";
+const idlUtils = require("../generated/utils");
+const { closest } = require("../helpers/traversal");
+const { isDisabled, isSubmittable, isButton, normalizeToCRLF } = require("../helpers/form-controls");
+const Blob = require("../generated/Blob.js");
+const File = require("../generated/File.js");
+const conversions = require("webidl-conversions");
+
+exports.implementation = class FormDataImpl {
+  constructor(globalObject, args) {
+    this._globalObject = globalObject;
+    this._entries = [];
+
+    if (args[0] !== undefined) {
+      this._entries = constructTheEntryList(args[0]);
+    }
+  }
+
+  append(name, value, filename) {
+    const entry = createAnEntry(name, value, filename);
+    this._entries.push(entry);
+  }
+
+  delete(name) {
+    this._entries = this._entries.filter(entry => entry.name !== name);
+  }
+
+  get(name) {
+    const foundEntry = this._entries.find(entry => entry.name === name);
+    return foundEntry !== undefined ? idlUtils.tryWrapperForImpl(foundEntry.value) : null;
+  }
+
+  getAll(name) {
+    return this._entries.filter(entry => entry.name === name).map(entry => idlUtils.tryWrapperForImpl(entry.value));
+  }
+
+  has(name) {
+    return this._entries.findIndex(entry => entry.name === name) !== -1;
+  }
+
+  set(name, value, filename) {
+    const entry = createAnEntry(name, value, filename);
+
+    const foundIndex = this._entries.findIndex(e => e.name === name);
+    if (foundIndex !== -1) {
+      this._entries[foundIndex] = entry;
+      this._entries = this._entries.filter((e, i) => e.name !== name || i === foundIndex);
+    } else {
+      this._entries.push(entry);
+    }
+  }
+
+  * [Symbol.iterator]() {
+    for (const entry of this._entries) {
+      yield [entry.name, idlUtils.tryWrapperForImpl(entry.value)];
+    }
+  }
+};
+
+function createAnEntry(name, value, filename) {
+  const entry = { name };
+
+  // https://github.com/whatwg/xhr/issues/75
+
+  if (Blob.isImpl(value) && !File.isImpl(value)) {
+    const oldValue = value;
+    value = File.createImpl(value._globalObject, [
+      [],
+      "blob",
+      { type: oldValue.type }
+    ]);
+    // "representing the same bytes"
+    value._buffer = oldValue._buffer;
+  }
+
+  if (File.isImpl(value) && filename !== undefined) {
+    const oldValue = value;
+    value = File.createImpl(value._globalObject, [
+      [],
+      filename,
+      // spec makes no mention of `lastModified`; assume it is inherited
+      // (Chrome's behavior)
+      { type: oldValue.type, lastModified: oldValue.lastModified }
+    ]);
+    // "representing the same bytes"
+    value._buffer = oldValue._buffer;
+  }
+
+  entry.value = value;
+
+  return entry;
+}
+
+function constructTheEntryList(form, submitter) {
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#constructing-the-form-data-set
+  // TODO: handle encoding
+  // TODO: handling "constructing entry list"
+
+  const controls = form.elements.filter(isSubmittable); // submittable is a subset of listed
+  const entryList = [];
+
+  for (const field of controls) {
+    if (closest(field, "datalist") !== null) {
+      continue;
+    }
+    if (isDisabled(field)) {
+      continue;
+    }
+    if (isButton(field) && field !== submitter) {
+      continue;
+    }
+    if (field.type === "checkbox" && field._checkedness === false) {
+      continue;
+    }
+    if (field.type === "radio" && field._checkedness === false) {
+      continue;
+    }
+    if (field.localName === "object") { // in jsdom, no objects are "using a plugin"
+      continue;
+    }
+
+    // TODO: Handle <input type="image">
+    // TODO: handle form-associated custom elements.
+
+    const name = field.getAttributeNS(null, "name");
+    if (name === null || name === "") {
+      continue;
+    }
+
+    if (field.localName === "select") {
+      for (const option of field.options) {
+        if (option._selectedness === true && !isDisabled(field)) {
+          appendAnEntry(entryList, name, option._getValue());
+        }
+      }
+    } else if (field.localName === "input" && (field.type === "checkbox" || field.type === "radio")) {
+      const value = field.hasAttributeNS(null, "value") ? field.getAttributeNS(null, "value") : "on";
+      appendAnEntry(entryList, name, value);
+    } else if (field.type === "file") {
+      if (field.files.length === 0) {
+        const value = File.createImpl(form._globalObject, [[], "", { type: "application/octet-stream" }]);
+        appendAnEntry(entryList, name, value);
+      } else {
+        for (let i = 0; i < field.files.length; ++i) {
+          appendAnEntry(entryList, name, field.files.item(i));
+        }
+      }
+    } /* skip plugins. TODO: _charset_ */ else if (field.localName === "textarea") {
+      appendAnEntry(entryList, name, field._getValue(), true);
+    } else {
+      appendAnEntry(entryList, name, field._getValue());
+    }
+
+    const dirname = field.getAttributeNS(null, "dirname");
+    if (dirname !== null && dirname !== "") {
+      const dir = "ltr"; // jsdom does not (yet?) implement actual directionality
+      appendAnEntry(entryList, dirname, dir);
+    }
+  }
+
+  // TODO: formdata event
+
+  return entryList;
+}
+
+function appendAnEntry(entryList, name, value, preventLineBreakNormalization = false) {
+  name = conversions.USVString(normalizeToCRLF(name));
+  if (!File.isImpl(value)) {
+    if (!preventLineBreakNormalization) {
+      value = normalizeToCRLF(value);
+    }
+    value = conversions.USVString(value);
+  }
+  const entry = createAnEntry(name, value);
+  entryList.push(entry);
+}
diff --git a/lib/jsdom/living/xhr/XMLHttpRequest-impl.js b/lib/jsdom/living/xhr/XMLHttpRequest-impl.js
new file mode 100644
index 0000000..768c712
--- /dev/null
+++ b/lib/jsdom/living/xhr/XMLHttpRequest-impl.js
@@ -0,0 +1,1022 @@
+"use strict";
+
+const HTTP_STATUS_CODES = require("http").STATUS_CODES;
+const { spawnSync } = require("child_process");
+const { URL } = require("whatwg-url");
+const whatwgEncoding = require("whatwg-encoding");
+const tough = require("tough-cookie");
+const MIMEType = require("whatwg-mimetype");
+
+const xhrUtils = require("./xhr-utils");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { documentBaseURLSerialized } = require("../helpers/document-base-url");
+const { asciiCaseInsensitiveMatch } = require("../helpers/strings");
+const idlUtils = require("../generated/utils");
+const Document = require("../generated/Document");
+const Blob = require("../generated/Blob");
+const FormData = require("../generated/FormData");
+const XMLHttpRequestEventTargetImpl = require("./XMLHttpRequestEventTarget-impl").implementation;
+const XMLHttpRequestUpload = require("../generated/XMLHttpRequestUpload");
+const ProgressEvent = require("../generated/ProgressEvent");
+const { isArrayBuffer } = require("../generated/utils");
+const { parseIntoDocument } = require("../../browser/parser");
+const { fragmentSerialization } = require("../domparsing/serialization");
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { parseJSONFromBytes } = require("../helpers/json");
+const { fireAnEvent } = require("../helpers/events");
+const { copyToArrayBufferInNewRealm } = require("../helpers/binary-data");
+
+const { READY_STATES } = xhrUtils;
+
+const syncWorkerFile = require.resolve ? require.resolve("./xhr-sync-worker.js") : null;
+
+const tokenRegexp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const fieldValueRegexp = /^[ \t]*(?:[\x21-\x7E\x80-\xFF](?:[ \t][\x21-\x7E\x80-\xFF])?)*[ \t]*$/;
+
+const forbiddenRequestHeaders = new Set([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+const forbiddenResponseHeaders = new Set([
+  "set-cookie",
+  "set-cookie2"
+]);
+const uniqueResponseHeaders = new Set([
+  "content-type",
+  "content-length",
+  "user-agent",
+  "referer",
+  "host",
+  "authorization",
+  "proxy-authorization",
+  "if-modified-since",
+  "if-unmodified-since",
+  "from",
+  "location",
+  "max-forwards"
+]);
+const corsSafeResponseHeaders = new Set([
+  "cache-control",
+  "content-language",
+  "content-type",
+  "expires",
+  "last-modified",
+  "pragma"
+]);
+
+const allowedRequestMethods = new Set(["OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE"]);
+const forbiddenRequestMethods = new Set(["TRACK", "TRACE", "CONNECT"]);
+
+class XMLHttpRequestImpl extends XMLHttpRequestEventTargetImpl {
+  constructor(window) {
+    super(window);
+
+    // Avoid running `_ownerDocument` getter multiple times in the constructor:
+    const { _ownerDocument } = this;
+
+    this.upload = XMLHttpRequestUpload.createImpl(window);
+
+    this.readyState = READY_STATES.UNSENT;
+    this.responseURL = "";
+    this.status = 0;
+    this.statusText = "";
+
+    this.flag = {
+      synchronous: false,
+      withCredentials: false,
+      mimeType: null,
+      auth: null,
+      method: undefined,
+      responseType: "",
+      requestHeaders: {},
+      referrer: _ownerDocument.URL,
+      uri: "",
+      timeout: 0,
+      body: undefined,
+      formData: false,
+      preflight: false,
+      requestManager: _ownerDocument._requestManager,
+      strictSSL: window._resourceLoader._strictSSL,
+      proxy: window._resourceLoader._proxy,
+      cookieJar: _ownerDocument._cookieJar,
+      encoding: _ownerDocument._encoding,
+      origin: window._origin,
+      userAgent: window.navigator.userAgent
+    };
+
+    this.properties = {
+      beforeSend: false,
+      send: false,
+      client: null,
+
+      timeoutStart: 0,
+      timeoutId: 0,
+      timeoutFn: null,
+
+      responseBuffer: null,
+      responseCache: null,
+      responseTextCache: null,
+      responseXMLCache: null,
+
+      responseHeaders: {},
+      filteredResponseHeaders: [],
+
+      error: "",
+      uploadComplete: false,
+      uploadListener: false,
+
+      // Signifies that we're calling abort() from xhr-utils.js because of a window shutdown.
+      // In that case the termination reason is "fatal", not "end-user abort".
+      abortError: false,
+
+      cookieJar: _ownerDocument._cookieJar,
+      bufferStepSize: 1 * 1024 * 1024, // pre-allocate buffer increase step size. init value is 1MB
+      totalReceivedChunkSize: 0
+    };
+  }
+
+  get responseType() {
+    return this.flag.responseType;
+  }
+  set responseType(responseType) {
+    const { flag } = this;
+    if (this.readyState === READY_STATES.LOADING || this.readyState === READY_STATES.DONE) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+    if (this.readyState === READY_STATES.OPENED && flag.synchronous) {
+      throw DOMException.create(this._globalObject, [
+        "The object does not support the operation or argument.",
+        "InvalidAccessError"
+      ]);
+    }
+    flag.responseType = responseType;
+  }
+
+  get response() {
+    const { properties } = this;
+    if (properties.responseCache) {
+      // Needed because of: https://github.com/jsdom/webidl2js/issues/149
+      return idlUtils.tryWrapperForImpl(properties.responseCache);
+    }
+    let res;
+
+    const responseBuffer = properties.responseBuffer ?
+      properties.responseBuffer.slice(0, properties.totalReceivedChunkSize) :
+      null;
+
+    switch (this.responseType) {
+      case "":
+      case "text": {
+        res = this.responseText;
+        break;
+      }
+      case "arraybuffer": {
+        if (!responseBuffer) {
+          return null;
+        }
+        res = copyToArrayBufferInNewRealm(responseBuffer, this._globalObject);
+        break;
+      }
+      case "blob": {
+        if (!responseBuffer) {
+          return null;
+        }
+        const contentType = finalMIMEType(this);
+        res = Blob.createImpl(this._globalObject, [
+          [new Uint8Array(responseBuffer)],
+          { type: contentType || "" }
+        ]);
+        break;
+      }
+      case "document": {
+        res = this.responseXML;
+        break;
+      }
+      case "json": {
+        if (this.readyState !== READY_STATES.DONE || !responseBuffer) {
+          res = null;
+        }
+
+        try {
+          res = parseJSONFromBytes(responseBuffer);
+        } catch (e) {
+          res = null;
+        }
+        break;
+      }
+    }
+    properties.responseCache = res;
+    // Needed because of: https://github.com/jsdom/webidl2js/issues/149
+    return idlUtils.tryWrapperForImpl(res);
+  }
+  get responseText() {
+    const { properties } = this;
+    if (this.responseType !== "" && this.responseType !== "text") {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+    if (this.readyState !== READY_STATES.LOADING && this.readyState !== READY_STATES.DONE) {
+      return "";
+    }
+    if (properties.responseTextCache) {
+      return properties.responseTextCache;
+    }
+    const responseBuffer = properties.responseBuffer ?
+      properties.responseBuffer.slice(0, properties.totalReceivedChunkSize) :
+      null;
+
+    if (!responseBuffer) {
+      return "";
+    }
+
+    const fallbackEncoding = finalCharset(this) || whatwgEncoding.getBOMEncoding(responseBuffer) || "UTF-8";
+    const res = whatwgEncoding.decode(responseBuffer, fallbackEncoding);
+
+    properties.responseTextCache = res;
+    return res;
+  }
+  get responseXML() {
+    const { flag, properties } = this;
+    if (this.responseType !== "" && this.responseType !== "document") {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+    if (this.readyState !== READY_STATES.DONE) {
+      return null;
+    }
+    if (properties.responseXMLCache) {
+      return properties.responseXMLCache;
+    }
+    const responseBuffer = properties.responseBuffer ?
+      properties.responseBuffer.slice(0, properties.totalReceivedChunkSize) :
+      null;
+
+    if (!responseBuffer) {
+      return null;
+    }
+
+    const contentType = finalMIMEType(this);
+    let isHTML = false;
+    let isXML = false;
+    const parsed = MIMEType.parse(contentType);
+    if (parsed) {
+      isHTML = parsed.isHTML();
+      isXML = parsed.isXML();
+      if (!isXML && !isHTML) {
+        return null;
+      }
+    }
+
+    if (this.responseType === "" && isHTML) {
+      return null;
+    }
+
+    const encoding = finalCharset(this) || whatwgEncoding.getBOMEncoding(responseBuffer) || "UTF-8";
+    const resText = whatwgEncoding.decode(responseBuffer, encoding);
+
+    if (!resText) {
+      return null;
+    }
+    const res = Document.createImpl(this._globalObject, [], {
+      options: {
+        url: flag.uri,
+        lastModified: new Date(getResponseHeader(this, "last-modified")),
+        parsingMode: isHTML ? "html" : "xml",
+        cookieJar: { setCookieSync: () => undefined, getCookieStringSync: () => "" },
+        encoding,
+        parseOptions: this._ownerDocument._parseOptions
+      }
+    });
+    try {
+      parseIntoDocument(resText, res);
+    } catch (e) {
+      properties.responseXMLCache = null;
+      return null;
+    }
+    res.close();
+    properties.responseXMLCache = res;
+    return res;
+  }
+
+  get timeout() {
+    return this.flag.timeout;
+  }
+  set timeout(val) {
+    const { flag, properties } = this;
+    if (flag.synchronous) {
+      throw DOMException.create(this._globalObject, [
+        "The object does not support the operation or argument.",
+        "InvalidAccessError"
+      ]);
+    }
+    flag.timeout = val;
+    clearTimeout(properties.timeoutId);
+    if (val > 0 && properties.timeoutFn) {
+      properties.timeoutId = setTimeout(
+        properties.timeoutFn,
+        Math.max(0, val - ((new Date()).getTime() - properties.timeoutStart))
+      );
+    } else {
+      properties.timeoutFn = null;
+      properties.timeoutStart = 0;
+    }
+  }
+
+  get withCredentials() {
+    return this.flag.withCredentials;
+  }
+  set withCredentials(val) {
+    const { flag, properties } = this;
+    if (!(this.readyState === READY_STATES.UNSENT || this.readyState === READY_STATES.OPENED)) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+    if (properties.send) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+    flag.withCredentials = val;
+  }
+
+  abort() {
+    const { properties } = this;
+    // Terminate the request
+    clearTimeout(properties.timeoutId);
+    properties.timeoutFn = null;
+    properties.timeoutStart = 0;
+
+    const { client } = properties;
+    if (client) {
+      client.abort();
+      properties.client = null;
+    }
+
+    if (properties.abortError) {
+      // Special case that ideally shouldn't be going through the public API at all.
+      // Run the https://xhr.spec.whatwg.org/#handle-errors "fatal" steps.
+      this.readyState = READY_STATES.DONE;
+      properties.send = false;
+      xhrUtils.setResponseToNetworkError(this);
+      return;
+    }
+
+    if ((this.readyState === READY_STATES.OPENED && properties.send) ||
+        this.readyState === READY_STATES.HEADERS_RECEIVED ||
+        this.readyState === READY_STATES.LOADING) {
+      xhrUtils.requestErrorSteps(this, "abort");
+    }
+
+    if (this.readyState === READY_STATES.DONE) {
+      this.readyState = READY_STATES.UNSENT;
+
+      xhrUtils.setResponseToNetworkError(this);
+    }
+  }
+  getAllResponseHeaders() {
+    const { properties, readyState } = this;
+    if (readyState === READY_STATES.UNSENT || readyState === READY_STATES.OPENED) {
+      return "";
+    }
+    return Object.keys(properties.responseHeaders)
+      .filter(key => properties.filteredResponseHeaders.indexOf(key) === -1)
+      .map(key => [key.toLowerCase(), properties.responseHeaders[key]].join(": "))
+      .join("\r\n");
+  }
+
+  getResponseHeader(header) {
+    const { properties, readyState } = this;
+    if (readyState === READY_STATES.UNSENT || readyState === READY_STATES.OPENED) {
+      return null;
+    }
+    const lcHeader = header.toLowerCase();
+    if (properties.filteredResponseHeaders.find(filtered => lcHeader === filtered.toLowerCase())) {
+      return null;
+    }
+    return getResponseHeader(this, lcHeader);
+  }
+
+  open(method, uri, asynchronous, user, password) {
+    const { flag, properties, _ownerDocument } = this;
+    if (!_ownerDocument) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    if (!tokenRegexp.test(method)) {
+      throw DOMException.create(this._globalObject, [
+        "The string did not match the expected pattern.",
+        "SyntaxError"
+      ]);
+    }
+    const upperCaseMethod = method.toUpperCase();
+    if (forbiddenRequestMethods.has(upperCaseMethod)) {
+      throw DOMException.create(this._globalObject, ["The operation is insecure.", "SecurityError"]);
+    }
+
+    const { client } = properties;
+    if (client && typeof client.abort === "function") {
+      client.abort();
+    }
+
+    if (allowedRequestMethods.has(upperCaseMethod)) {
+      method = upperCaseMethod;
+    }
+    if (typeof asynchronous !== "undefined") {
+      flag.synchronous = !asynchronous;
+    } else {
+      flag.synchronous = false;
+    }
+    if (flag.responseType && flag.synchronous) {
+      throw DOMException.create(this._globalObject, [
+        "The object does not support the operation or argument.",
+        "InvalidAccessError"
+      ]);
+    }
+    if (flag.synchronous && flag.timeout) {
+      throw DOMException.create(this._globalObject, [
+        "The object does not support the operation or argument.",
+        "InvalidAccessError"
+      ]);
+    }
+    flag.method = method;
+
+    let urlObj;
+    try {
+      urlObj = new URL(uri, documentBaseURLSerialized(_ownerDocument));
+    } catch (e) {
+      throw DOMException.create(this._globalObject, [
+        "The string did not match the expected pattern.",
+        "SyntaxError"
+      ]);
+    }
+
+    if (user || (password && !urlObj.username)) {
+      flag.auth = {
+        user,
+        pass: password
+      };
+      urlObj.username = "";
+      urlObj.password = "";
+    }
+
+    flag.uri = urlObj.href;
+    flag.requestHeaders = {};
+    flag.preflight = false;
+
+    properties.send = false;
+    properties.uploadListener = false;
+    properties.abortError = false;
+    this.responseURL = "";
+    readyStateChange(this, READY_STATES.OPENED);
+  }
+
+  overrideMimeType(mime) {
+    const { readyState } = this;
+    if (readyState === READY_STATES.LOADING || readyState === READY_STATES.DONE) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    this.flag.overrideMIMEType = "application/octet-stream";
+
+    // Waiting for better spec: https://github.com/whatwg/xhr/issues/157
+    const parsed = MIMEType.parse(mime);
+    if (parsed) {
+      this.flag.overrideMIMEType = parsed.essence;
+
+      const charset = parsed.parameters.get("charset");
+      if (charset) {
+        this.flag.overrideCharset = whatwgEncoding.labelToName(charset);
+      }
+    }
+  }
+
+  // TODO: Add support for URLSearchParams and ReadableStream
+  send(body) {
+    const { flag, properties, upload, _ownerDocument } = this;
+    // Not per spec, but per tests: https://github.com/whatwg/xhr/issues/65
+    if (!_ownerDocument) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    if (this.readyState !== READY_STATES.OPENED || properties.send) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    properties.beforeSend = true;
+
+    try {
+      if (flag.method === "GET" || flag.method === "HEAD") {
+        body = null;
+      }
+
+      if (body !== null) {
+        let encoding = null;
+        let mimeType = null;
+
+        if (Document.isImpl(body)) {
+          encoding = "UTF-8";
+          mimeType = (body._parsingMode === "html" ? "text/html" : "application/xml") + ";charset=UTF-8";
+          flag.body = fragmentSerialization(body, { requireWellFormed: false });
+        } else {
+          if (typeof body === "string") {
+            encoding = "UTF-8";
+          }
+          const { buffer, formData, contentType } = extractBody(body);
+          mimeType = contentType;
+          flag.body = buffer || formData;
+          flag.formData = Boolean(formData);
+        }
+
+        const existingContentType = xhrUtils.getRequestHeader(flag.requestHeaders, "content-type");
+        if (mimeType !== null && existingContentType === null) {
+          flag.requestHeaders["Content-Type"] = mimeType;
+        } else if (existingContentType !== null && encoding !== null) {
+          // Waiting for better spec: https://github.com/whatwg/xhr/issues/188. This seems like a good guess at what
+          // the spec will be, in the meantime.
+          const parsed = MIMEType.parse(existingContentType);
+          if (parsed) {
+            const charset = parsed.parameters.get("charset");
+            if (charset && !asciiCaseInsensitiveMatch(charset, encoding) && encoding !== null) {
+              parsed.parameters.set("charset", encoding);
+              xhrUtils.updateRequestHeader(flag.requestHeaders, "content-type", parsed.toString());
+            }
+          }
+        }
+      }
+    } finally {
+      if (properties.beforeSend) {
+        properties.beforeSend = false;
+      } else {
+        throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+      }
+    }
+
+    if (Object.keys(upload._eventListeners).length > 0) {
+      properties.uploadListener = true;
+    }
+
+    // request doesn't like zero-length bodies
+    if (flag.body && flag.body.byteLength === 0) {
+      flag.body = null;
+    }
+
+    if (flag.synchronous) {
+      const flagStr = JSON.stringify(flag, function (k, v) {
+        if (this === flag && k === "requestManager") {
+          return null;
+        }
+        if (this === flag && k === "pool" && v) {
+          return { maxSockets: v.maxSockets };
+        }
+        return v;
+      });
+      const res = spawnSync(
+        process.execPath,
+        [syncWorkerFile],
+        { input: flagStr, maxBuffer: Infinity }
+      );
+      if (res.status !== 0) {
+        throw new Error(res.stderr.toString());
+      }
+      if (res.error) {
+        if (typeof res.error === "string") {
+          res.error = new Error(res.error);
+        }
+        throw res.error;
+      }
+
+      const response = JSON.parse(res.stdout.toString());
+      const resProp = response.properties;
+      if (resProp.responseBuffer && resProp.responseBuffer.data) {
+        resProp.responseBuffer = Buffer.from(resProp.responseBuffer.data);
+      }
+      if (resProp.cookieJar) {
+        resProp.cookieJar = tough.CookieJar.deserializeSync(
+          resProp.cookieJar,
+          _ownerDocument._cookieJar.store
+        );
+      }
+
+      this.readyState = READY_STATES.LOADING;
+      this.status = response.status;
+      this.statusText = response.statusText;
+      this.responseURL = response.responseURL;
+      Object.assign(this.properties, response.properties);
+
+      if (resProp.error) {
+        xhrUtils.dispatchError(this);
+        throw DOMException.create(this._globalObject, [resProp.error, "NetworkError"]);
+      } else {
+        const { responseBuffer } = properties;
+        const contentLength = getResponseHeader(this, "content-length") || "0";
+        const bufferLength = parseInt(contentLength) || responseBuffer.length;
+        const progressObj = { lengthComputable: false };
+        if (bufferLength !== 0) {
+          progressObj.total = bufferLength;
+          progressObj.loaded = bufferLength;
+          progressObj.lengthComputable = true;
+        }
+        fireAnEvent("progress", this, ProgressEvent, progressObj);
+        readyStateChange(this, READY_STATES.DONE);
+        fireAnEvent("load", this, ProgressEvent, progressObj);
+        fireAnEvent("loadend", this, ProgressEvent, progressObj);
+      }
+    } else {
+      properties.send = true;
+
+      fireAnEvent("loadstart", this, ProgressEvent);
+
+      const client = xhrUtils.createClient(this);
+
+      properties.client = client;
+      // For new client, reset totalReceivedChunkSize and bufferStepSize
+      properties.totalReceivedChunkSize = 0;
+      properties.bufferStepSize = 1 * 1024 * 1024;
+
+      properties.origin = flag.origin;
+
+      client.on("error", err => {
+        client.removeAllListeners();
+        properties.error = err;
+        xhrUtils.dispatchError(this);
+      });
+
+      client.on("response", res => receiveResponse(this, res));
+
+      client.on("redirect", () => {
+        const { response } = client;
+        const destUrlObj = new URL(response.request.headers.Referer);
+
+        const urlObj = new URL(response.request.uri.href);
+
+        if (destUrlObj.origin !== urlObj.origin && destUrlObj.origin !== flag.origin) {
+          properties.origin = "null";
+        }
+
+        response.request.headers.Origin = properties.origin;
+
+        if (flag.origin !== destUrlObj.origin &&
+            destUrlObj.protocol !== "data:") {
+          if (!xhrUtils.validCORSHeaders(this, response, flag, properties, flag.origin)) {
+            return;
+          }
+          if (urlObj.username || urlObj.password) {
+            properties.error = "Userinfo forbidden in cors redirect";
+            xhrUtils.dispatchError(this);
+          }
+        }
+      });
+      if (body !== null && body !== "") {
+        properties.uploadComplete = false;
+        setDispatchProgressEvents(this);
+      } else {
+        properties.uploadComplete = true;
+      }
+      if (this.timeout > 0) {
+        properties.timeoutStart = (new Date()).getTime();
+        properties.timeoutFn = () => {
+          client.abort();
+          if (!(this.readyState === READY_STATES.UNSENT ||
+              (this.readyState === READY_STATES.OPENED && !properties.send) ||
+              this.readyState === READY_STATES.DONE)) {
+            properties.send = false;
+            let stateChanged = false;
+            if (!properties.uploadComplete) {
+              fireAnEvent("progress", upload, ProgressEvent);
+              readyStateChange(this, READY_STATES.DONE);
+              fireAnEvent("timeout", upload, ProgressEvent);
+              fireAnEvent("loadend", upload, ProgressEvent);
+              stateChanged = true;
+            }
+            fireAnEvent("progress", this, ProgressEvent);
+            if (!stateChanged) {
+              readyStateChange(this, READY_STATES.DONE);
+            }
+            fireAnEvent("timeout", this, ProgressEvent);
+            fireAnEvent("loadend", this, ProgressEvent);
+          }
+          this.readyState = READY_STATES.UNSENT;
+        };
+        properties.timeoutId = setTimeout(properties.timeoutFn, this.timeout);
+      }
+    }
+  }
+
+  setRequestHeader(header, value) {
+    const { flag, properties } = this;
+
+    if (this.readyState !== READY_STATES.OPENED || properties.send) {
+      throw DOMException.create(this._globalObject, ["The object is in an invalid state.", "InvalidStateError"]);
+    }
+
+    value = normalizeHeaderValue(value);
+
+    if (!tokenRegexp.test(header) || !fieldValueRegexp.test(value)) {
+      throw DOMException.create(this._globalObject, [
+        "The string did not match the expected pattern.",
+        "SyntaxError"
+      ]);
+    }
+
+    const lcHeader = header.toLowerCase();
+
+    if (forbiddenRequestHeaders.has(lcHeader) || lcHeader.startsWith("sec-") || lcHeader.startsWith("proxy-")) {
+      return;
+    }
+
+    const keys = Object.keys(flag.requestHeaders);
+    let n = keys.length;
+    while (n--) {
+      const key = keys[n];
+      if (key.toLowerCase() === lcHeader) {
+        flag.requestHeaders[key] += ", " + value;
+        return;
+      }
+    }
+    flag.requestHeaders[header] = value;
+  }
+}
+
+setupForSimpleEventAccessors(XMLHttpRequestImpl.prototype, ["readystatechange"]);
+
+function readyStateChange(xhr, readyState) {
+  if (xhr.readyState === readyState) {
+    return;
+  }
+
+  xhr.readyState = readyState;
+
+  fireAnEvent("readystatechange", xhr);
+}
+
+function receiveResponse(xhr, response) {
+  const { flag, properties } = xhr;
+  const { statusCode } = response;
+
+  let byteOffset = 0;
+
+  const headers = {};
+  const filteredResponseHeaders = [];
+  const headerMap = {};
+  const { rawHeaders } = response;
+  const n = Number(rawHeaders.length);
+  for (let i = 0; i < n; i += 2) {
+    const k = rawHeaders[i];
+    const kl = k.toLowerCase();
+    const v = rawHeaders[i + 1];
+    if (uniqueResponseHeaders.has(kl)) {
+      if (headerMap[kl] !== undefined) {
+        delete headers[headerMap[kl]];
+      }
+      headers[k] = v;
+    } else if (headerMap[kl] !== undefined) {
+      headers[headerMap[kl]] += ", " + v;
+    } else {
+      headers[k] = v;
+    }
+    headerMap[kl] = k;
+  }
+
+  const destUrlObj = new URL(response.request.uri.href);
+  if (properties.origin !== destUrlObj.origin &&
+      destUrlObj.protocol !== "data:") {
+    if (!xhrUtils.validCORSHeaders(xhr, response, flag, properties, properties.origin)) {
+      return;
+    }
+    const acehStr = response.headers["access-control-expose-headers"];
+    const aceh = new Set(acehStr ? acehStr.trim().toLowerCase().split(xhrUtils.headerListSeparatorRegexp) : []);
+    for (const header in headers) {
+      const lcHeader = header.toLowerCase();
+      if (!corsSafeResponseHeaders.has(lcHeader) && !aceh.has(lcHeader)) {
+        filteredResponseHeaders.push(header);
+      }
+    }
+  }
+
+  for (const header in headers) {
+    const lcHeader = header.toLowerCase();
+    if (forbiddenResponseHeaders.has(lcHeader)) {
+      filteredResponseHeaders.push(header);
+    }
+  }
+
+  xhr.responseURL = destUrlObj.href;
+
+  xhr.status = statusCode;
+  xhr.statusText = response.statusMessage || HTTP_STATUS_CODES[statusCode] || "";
+
+  properties.responseHeaders = headers;
+  properties.filteredResponseHeaders = filteredResponseHeaders;
+
+  const contentLength = getResponseHeader(xhr, "content-length") || "0";
+  const bufferLength = parseInt(contentLength) || 0;
+  const progressObj = { lengthComputable: false };
+  let lastProgressReported;
+  if (bufferLength !== 0) {
+    progressObj.total = bufferLength;
+    progressObj.loaded = 0;
+    progressObj.lengthComputable = true;
+  }
+  // pre-allocate buffer.
+  properties.responseBuffer = Buffer.alloc(properties.bufferStepSize);
+  properties.responseCache = null;
+  properties.responseTextCache = null;
+  properties.responseXMLCache = null;
+  readyStateChange(xhr, READY_STATES.HEADERS_RECEIVED);
+
+  if (!properties.client) {
+    // The request was aborted in reaction to the readystatechange event.
+    return;
+  }
+
+  // Can't use the client since the client gets the post-ungzipping bytes (which can be greater than the
+  // Content-Length).
+  response.on("data", chunk => {
+    byteOffset += chunk.length;
+    progressObj.loaded = byteOffset;
+  });
+
+  properties.client.on("data", chunk => {
+    properties.totalReceivedChunkSize += chunk.length;
+    if (properties.totalReceivedChunkSize >= properties.bufferStepSize) {
+      properties.bufferStepSize *= 2;
+      while (properties.totalReceivedChunkSize >= properties.bufferStepSize) {
+        properties.bufferStepSize *= 2;
+      }
+      const tmpBuf = Buffer.alloc(properties.bufferStepSize);
+      properties.responseBuffer.copy(tmpBuf, 0, 0, properties.responseBuffer.length);
+      properties.responseBuffer = tmpBuf;
+    }
+    chunk.copy(properties.responseBuffer, properties.totalReceivedChunkSize - chunk.length, 0, chunk.length);
+    properties.responseCache = null;
+    properties.responseTextCache = null;
+    properties.responseXMLCache = null;
+
+    if (xhr.readyState === READY_STATES.HEADERS_RECEIVED) {
+      xhr.readyState = READY_STATES.LOADING;
+    }
+    fireAnEvent("readystatechange", xhr);
+
+    if (progressObj.total !== progressObj.loaded || properties.totalReceivedChunkSize === byteOffset) {
+      if (lastProgressReported !== progressObj.loaded) {
+        // This is a necessary check in the gzip case where we can be getting new data from the client, as it
+        // un-gzips, but no new data has been gotten from the response, so we should not fire a progress event.
+        lastProgressReported = progressObj.loaded;
+        fireAnEvent("progress", xhr, ProgressEvent, progressObj);
+      }
+    }
+  });
+  properties.client.on("end", () => {
+    clearTimeout(properties.timeoutId);
+    properties.timeoutFn = null;
+    properties.timeoutStart = 0;
+    properties.client = null;
+    fireAnEvent("progress", xhr, ProgressEvent, progressObj);
+    readyStateChange(xhr, READY_STATES.DONE);
+    fireAnEvent("load", xhr, ProgressEvent, progressObj);
+    fireAnEvent("loadend", xhr, ProgressEvent, progressObj);
+  });
+}
+
+function setDispatchProgressEvents(xhr) {
+  const { properties, upload } = xhr;
+  const { client } = properties;
+
+  let total = 0;
+  let lengthComputable = false;
+  const length = client.headers && parseInt(xhrUtils.getRequestHeader(client.headers, "content-length"));
+  if (length) {
+    total = length;
+    lengthComputable = true;
+  }
+  const initProgress = {
+    lengthComputable,
+    total,
+    loaded: 0
+  };
+
+  if (properties.uploadListener) {
+    fireAnEvent("loadstart", upload, ProgressEvent, initProgress);
+  }
+
+  client.on("request", req => {
+    req.on("response", () => {
+      properties.uploadComplete = true;
+
+      if (!properties.uploadListener) {
+        return;
+      }
+
+      const progress = {
+        lengthComputable,
+        total,
+        loaded: total
+      };
+      fireAnEvent("progress", upload, ProgressEvent, progress);
+      fireAnEvent("load", upload, ProgressEvent, progress);
+      fireAnEvent("loadend", upload, ProgressEvent, progress);
+    });
+  });
+}
+
+function finalMIMEType(xhr) {
+  const { flag } = xhr;
+  return flag.overrideMIMEType || getResponseHeader(xhr, "content-type");
+}
+
+function finalCharset(xhr) {
+  const { flag } = xhr;
+  if (flag.overrideCharset) {
+    return flag.overrideCharset;
+  }
+  const parsedContentType = MIMEType.parse(getResponseHeader(xhr, "content-type"));
+  if (parsedContentType) {
+    return whatwgEncoding.labelToName(parsedContentType.parameters.get("charset"));
+  }
+  return null;
+}
+
+function getResponseHeader(xhr, lcHeader) {
+  const { properties } = xhr;
+  const keys = Object.keys(properties.responseHeaders);
+  let n = keys.length;
+  while (n--) {
+    const key = keys[n];
+    if (key.toLowerCase() === lcHeader) {
+      return properties.responseHeaders[key];
+    }
+  }
+  return null;
+}
+
+function normalizeHeaderValue(value) {
+  return value.replace(/^[\x09\x0A\x0D\x20]+/, "").replace(/[\x09\x0A\x0D\x20]+$/, "");
+}
+
+function extractBody(bodyInit) {
+  // https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+  // except we represent the body as a Node.js Buffer instead,
+  // or a special case for FormData since we want request to handle that. Probably it would be
+  // cleaner (and allow a future without request) if we did the form encoding ourself.
+
+  if (Blob.isImpl(bodyInit)) {
+    return {
+      buffer: bodyInit._buffer,
+      contentType: bodyInit.type === "" ? null : bodyInit.type
+    };
+  } else if (isArrayBuffer(bodyInit)) {
+    return {
+      buffer: Buffer.from(bodyInit),
+      contentType: null
+    };
+  } else if (ArrayBuffer.isView(bodyInit)) {
+    return {
+      buffer: Buffer.from(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength),
+      contentType: null
+    };
+  } else if (FormData.isImpl(bodyInit)) {
+    const formData = [];
+    for (const entry of bodyInit._entries) {
+      let val;
+      if (Blob.isImpl(entry.value)) {
+        const blob = entry.value;
+        val = {
+          name: entry.name,
+          value: blob._buffer,
+          options: {
+            filename: blob.name,
+            contentType: blob.type,
+            knownLength: blob.size
+          }
+        };
+      } else {
+        val = entry;
+      }
+
+      formData.push(val);
+    }
+
+    return { formData };
+  }
+
+  // Must be a string
+  return {
+    buffer: Buffer.from(bodyInit, "utf-8"),
+    contentType: "text/plain;charset=UTF-8"
+  };
+}
+
+exports.implementation = XMLHttpRequestImpl;
diff --git a/lib/jsdom/living/xhr/XMLHttpRequestEventTarget-impl.js b/lib/jsdom/living/xhr/XMLHttpRequestEventTarget-impl.js
new file mode 100644
index 0000000..0455515
--- /dev/null
+++ b/lib/jsdom/living/xhr/XMLHttpRequestEventTarget-impl.js
@@ -0,0 +1,17 @@
+"use strict";
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+const idlUtils = require("../generated/utils");
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+
+const events = ["loadstart", "progress", "abort", "error", "load", "timeout", "loadend"];
+
+class XMLHttpRequestEventTargetImpl extends EventTargetImpl {
+  // TODO: remove this when we fix EventTargetImpl to use this._globalObject directly instead of using _ownerDocument.
+  // https://github.com/jsdom/jsdom/issues/2780
+  get _ownerDocument() {
+    return idlUtils.implForWrapper(this._globalObject._document);
+  }
+}
+setupForSimpleEventAccessors(XMLHttpRequestEventTargetImpl.prototype, events);
+
+exports.implementation = XMLHttpRequestEventTargetImpl;
diff --git a/lib/jsdom/living/xhr/XMLHttpRequestUpload-impl.js b/lib/jsdom/living/xhr/XMLHttpRequestUpload-impl.js
new file mode 100644
index 0000000..c91071c
--- /dev/null
+++ b/lib/jsdom/living/xhr/XMLHttpRequestUpload-impl.js
@@ -0,0 +1,4 @@
+"use strict";
+const XMLHttpRequestEventTargetImpl = require("./XMLHttpRequestEventTarget-impl").implementation;
+
+exports.implementation = class XMLHttpRequestUploadImpl extends XMLHttpRequestEventTargetImpl {};
diff --git a/lib/jsdom/living/xhr/xhr-sync-worker.js b/lib/jsdom/living/xhr/xhr-sync-worker.js
new file mode 100644
index 0000000..b65613b
--- /dev/null
+++ b/lib/jsdom/living/xhr/xhr-sync-worker.js
@@ -0,0 +1,60 @@
+"use strict";
+/* eslint-disable no-process-exit */
+const util = require("util");
+const { JSDOM } = require("../../../api");
+const { READY_STATES } = require("./xhr-utils");
+const idlUtils = require("../generated/utils");
+const tough = require("tough-cookie");
+
+const dom = new JSDOM();
+const xhr = new dom.window.XMLHttpRequest();
+const xhrImpl = idlUtils.implForWrapper(xhr);
+
+const chunks = [];
+
+process.stdin.on("data", chunk => {
+  chunks.push(chunk);
+});
+
+process.stdin.on("end", () => {
+  const buffer = Buffer.concat(chunks);
+
+  const flag = JSON.parse(buffer.toString());
+  if (flag.body && flag.body.type === "Buffer" && flag.body.data) {
+    flag.body = Buffer.from(flag.body.data);
+  }
+  if (flag.cookieJar) {
+    flag.cookieJar = tough.CookieJar.fromJSON(flag.cookieJar);
+  }
+
+  flag.synchronous = false;
+  Object.assign(xhrImpl.flag, flag);
+  const { properties } = xhrImpl;
+  xhrImpl.readyState = READY_STATES.OPENED;
+  try {
+    xhr.addEventListener("loadend", () => {
+      if (properties.error) {
+        properties.error = properties.error.stack || util.inspect(properties.error);
+      }
+      process.stdout.write(JSON.stringify({
+        responseURL: xhrImpl.responseURL,
+        status: xhrImpl.status,
+        statusText: xhrImpl.statusText,
+        properties
+      }), () => {
+        process.exit(0);
+      });
+    }, false);
+    xhr.send(flag.body);
+  } catch (error) {
+    properties.error += error.stack || util.inspect(error);
+    process.stdout.write(JSON.stringify({
+      responseURL: xhrImpl.responseURL,
+      status: xhrImpl.status,
+      statusText: xhrImpl.statusText,
+      properties
+    }), () => {
+      process.exit(0);
+    });
+  }
+});
diff --git a/lib/jsdom/living/xhr/xhr-utils.js b/lib/jsdom/living/xhr/xhr-utils.js
new file mode 100644
index 0000000..748ba40
--- /dev/null
+++ b/lib/jsdom/living/xhr/xhr-utils.js
@@ -0,0 +1,425 @@
+"use strict";
+const fs = require("fs");
+const request = require("request");
+const { EventEmitter } = require("events");
+const { URL } = require("whatwg-url");
+const parseDataURL = require("data-urls");
+const DOMException = require("domexception/webidl2js-wrapper");
+
+const ProgressEvent = require("../generated/ProgressEvent");
+
+const wrapCookieJarForRequest = require("../helpers/wrap-cookie-jar-for-request");
+const { fireAnEvent } = require("../helpers/events");
+
+const headerListSeparatorRegexp = /,[ \t]*/;
+const simpleMethods = new Set(["GET", "HEAD", "POST"]);
+const simpleHeaders = new Set(["accept", "accept-language", "content-language", "content-type"]);
+const preflightHeaders = new Set([
+  "access-control-expose-headers",
+  "access-control-allow-headers",
+  "access-control-allow-credentials",
+  "access-control-allow-origin"
+]);
+
+const READY_STATES = exports.READY_STATES = Object.freeze({
+  UNSENT: 0,
+  OPENED: 1,
+  HEADERS_RECEIVED: 2,
+  LOADING: 3,
+  DONE: 4
+});
+
+function getRequestHeader(requestHeaders, header) {
+  const lcHeader = header.toLowerCase();
+  const keys = Object.keys(requestHeaders);
+  let n = keys.length;
+  while (n--) {
+    const key = keys[n];
+    if (key.toLowerCase() === lcHeader) {
+      return requestHeaders[key];
+    }
+  }
+  return null;
+}
+
+function updateRequestHeader(requestHeaders, header, newValue) {
+  const lcHeader = header.toLowerCase();
+  const keys = Object.keys(requestHeaders);
+  let n = keys.length;
+  while (n--) {
+    const key = keys[n];
+    if (key.toLowerCase() === lcHeader) {
+      requestHeaders[key] = newValue;
+    }
+  }
+}
+
+function dispatchError(xhr) {
+  const errMessage = xhr.properties.error;
+  requestErrorSteps(xhr, "error", DOMException.create(xhr._globalObject, [errMessage, "NetworkError"]));
+
+  if (xhr._ownerDocument) {
+    const error = new Error(errMessage);
+    error.type = "XMLHttpRequest"; // TODO this should become "resource loading" when XHR goes through resource loader
+
+    xhr._ownerDocument._defaultView._virtualConsole.emit("jsdomError", error);
+  }
+}
+
+function validCORSHeaders(xhr, response, flag, properties, origin) {
+  const acaoStr = response.headers["access-control-allow-origin"];
+  const acao = acaoStr ? acaoStr.trim() : null;
+  if (acao !== "*" && acao !== origin) {
+    properties.error = "Cross origin " + origin + " forbidden";
+    dispatchError(xhr);
+    return false;
+  }
+  const acacStr = response.headers["access-control-allow-credentials"];
+  const acac = acacStr ? acacStr.trim() : null;
+  if (flag.withCredentials && acac !== "true") {
+    properties.error = "Credentials forbidden";
+    dispatchError(xhr);
+    return false;
+  }
+  return true;
+}
+
+function validCORSPreflightHeaders(xhr, response, flag, properties) {
+  if (!validCORSHeaders(xhr, response, flag, properties, properties.origin)) {
+    return false;
+  }
+  const acahStr = response.headers["access-control-allow-headers"];
+  const acah = new Set(acahStr ? acahStr.trim().toLowerCase().split(headerListSeparatorRegexp) : []);
+  const forbiddenHeaders = Object.keys(flag.requestHeaders).filter(header => {
+    const lcHeader = header.toLowerCase();
+    return !simpleHeaders.has(lcHeader) && !acah.has(lcHeader);
+  });
+  if (forbiddenHeaders.length > 0) {
+    properties.error = "Headers " + forbiddenHeaders + " forbidden";
+    dispatchError(xhr);
+    return false;
+  }
+  return true;
+}
+
+function requestErrorSteps(xhr, event, exception) {
+  const { flag, properties, upload } = xhr;
+
+  xhr.readyState = READY_STATES.DONE;
+  properties.send = false;
+
+  setResponseToNetworkError(xhr);
+
+  if (flag.synchronous) {
+    throw exception;
+  }
+
+  fireAnEvent("readystatechange", xhr);
+
+  if (!properties.uploadComplete) {
+    properties.uploadComplete = true;
+
+    if (properties.uploadListener) {
+      fireAnEvent(event, upload, ProgressEvent, { loaded: 0, total: 0, lengthComputable: false });
+      fireAnEvent("loadend", upload, ProgressEvent, { loaded: 0, total: 0, lengthComputable: false });
+    }
+  }
+
+  fireAnEvent(event, xhr, ProgressEvent, { loaded: 0, total: 0, lengthComputable: false });
+  fireAnEvent("loadend", xhr, ProgressEvent, { loaded: 0, total: 0, lengthComputable: false });
+}
+
+function setResponseToNetworkError(xhr) {
+  const { properties } = xhr;
+  properties.responseCache = properties.responseTextCache = properties.responseXMLCache = null;
+  properties.responseHeaders = {};
+  xhr.status = 0;
+  xhr.statusText = "";
+}
+
+// return a "request" client object or an event emitter matching the same behaviour for unsupported protocols
+// the callback should be called with a "request" response object or an event emitter matching the same behaviour too
+function createClient(xhr) {
+  const { flag, properties } = xhr;
+  const urlObj = new URL(flag.uri);
+  const uri = urlObj.href;
+  const ucMethod = flag.method.toUpperCase();
+
+  const { requestManager } = flag;
+
+  if (urlObj.protocol === "file:") {
+    const response = new EventEmitter();
+    response.statusCode = 200;
+    response.rawHeaders = [];
+    response.headers = {};
+    response.request = { uri: urlObj };
+    const filePath = urlObj.pathname
+      .replace(/^file:\/\//, "")
+      .replace(/^\/([a-z]):\//i, "$1:/")
+      .replace(/%20/g, " ");
+
+    const client = new EventEmitter();
+
+    const readableStream = fs.createReadStream(filePath, { encoding: null });
+
+    readableStream.on("data", chunk => {
+      response.emit("data", chunk);
+      client.emit("data", chunk);
+    });
+
+    readableStream.on("end", () => {
+      response.emit("end");
+      client.emit("end");
+    });
+
+    readableStream.on("error", err => {
+      client.emit("error", err);
+    });
+
+    client.abort = function () {
+      readableStream.destroy();
+      client.emit("abort");
+    };
+
+    if (requestManager) {
+      const req = {
+        abort() {
+          properties.abortError = true;
+          xhr.abort();
+        }
+      };
+      requestManager.add(req);
+      const rmReq = requestManager.remove.bind(requestManager, req);
+      client.on("abort", rmReq);
+      client.on("error", rmReq);
+      client.on("end", rmReq);
+    }
+
+    process.nextTick(() => client.emit("response", response));
+
+    return client;
+  }
+
+  if (urlObj.protocol === "data:") {
+    const response = new EventEmitter();
+
+    response.request = { uri: urlObj };
+
+    const client = new EventEmitter();
+
+    let buffer;
+    try {
+      const parsed = parseDataURL(uri);
+      const contentType = parsed.mimeType.toString();
+      buffer = parsed.body;
+      response.statusCode = 200;
+      response.rawHeaders = ["Content-Type", contentType];
+      response.headers = { "content-type": contentType };
+    } catch (err) {
+      process.nextTick(() => client.emit("error", err));
+      return client;
+    }
+
+    client.abort = () => {
+      // do nothing
+    };
+
+    process.nextTick(() => {
+      client.emit("response", response);
+      process.nextTick(() => {
+        response.emit("data", buffer);
+        client.emit("data", buffer);
+        response.emit("end");
+        client.emit("end");
+      });
+    });
+
+    return client;
+  }
+
+  const requestHeaders = {};
+
+  for (const header in flag.requestHeaders) {
+    requestHeaders[header] = flag.requestHeaders[header];
+  }
+
+  if (getRequestHeader(flag.requestHeaders, "referer") === null) {
+    requestHeaders.Referer = flag.referrer;
+  }
+  if (getRequestHeader(flag.requestHeaders, "user-agent") === null) {
+    requestHeaders["User-Agent"] = flag.userAgent;
+  }
+  if (getRequestHeader(flag.requestHeaders, "accept-language") === null) {
+    requestHeaders["Accept-Language"] = "en";
+  }
+  if (getRequestHeader(flag.requestHeaders, "accept") === null) {
+    requestHeaders.Accept = "*/*";
+  }
+
+  const crossOrigin = flag.origin !== urlObj.origin;
+  if (crossOrigin) {
+    requestHeaders.Origin = flag.origin;
+  }
+
+  const options = {
+    uri,
+    method: flag.method,
+    headers: requestHeaders,
+    gzip: true,
+    maxRedirects: 21,
+    followAllRedirects: true,
+    encoding: null,
+    strictSSL: flag.strictSSL,
+    proxy: flag.proxy,
+    forever: true
+  };
+  if (flag.auth) {
+    options.auth = {
+      user: flag.auth.user || "",
+      pass: flag.auth.pass || "",
+      sendImmediately: false
+    };
+  }
+  if (flag.cookieJar && (!crossOrigin || flag.withCredentials)) {
+    options.jar = wrapCookieJarForRequest(flag.cookieJar);
+  }
+
+  const { body } = flag;
+  const hasBody = body !== undefined &&
+                  body !== null &&
+                  body !== "" &&
+                  !(ucMethod === "HEAD" || ucMethod === "GET");
+
+  if (hasBody && !flag.formData) {
+    options.body = body;
+  }
+
+  if (hasBody && getRequestHeader(flag.requestHeaders, "content-type") === null) {
+    requestHeaders["Content-Type"] = "text/plain;charset=UTF-8";
+  }
+
+  function doRequest() {
+    try {
+      const client = request(options);
+
+      if (hasBody && flag.formData) {
+        const form = client.form();
+        for (const entry of body) {
+          form.append(entry.name, entry.value, entry.options);
+        }
+      }
+
+      return client;
+    } catch (e) {
+      const client = new EventEmitter();
+      process.nextTick(() => client.emit("error", e));
+      return client;
+    }
+  }
+
+  let client;
+
+  const nonSimpleHeaders = Object.keys(flag.requestHeaders)
+    .filter(header => !simpleHeaders.has(header.toLowerCase()));
+
+  if (crossOrigin && (!simpleMethods.has(ucMethod) || nonSimpleHeaders.length > 0 || properties.uploadListener)) {
+    client = new EventEmitter();
+
+    const preflightRequestHeaders = [];
+    for (const header in requestHeaders) {
+      // the only existing request headers the cors spec allows on the preflight request are Origin and Referrer
+      const lcHeader = header.toLowerCase();
+      if (lcHeader === "origin" || lcHeader === "referrer") {
+        preflightRequestHeaders[header] = requestHeaders[header];
+      }
+    }
+
+    preflightRequestHeaders["Access-Control-Request-Method"] = flag.method;
+    if (nonSimpleHeaders.length > 0) {
+      preflightRequestHeaders["Access-Control-Request-Headers"] = nonSimpleHeaders.join(", ");
+    }
+
+    preflightRequestHeaders["User-Agent"] = flag.userAgent;
+
+    flag.preflight = true;
+
+    const preflightOptions = {
+      uri,
+      method: "OPTIONS",
+      headers: preflightRequestHeaders,
+      followRedirect: false,
+      encoding: null,
+      pool: flag.pool,
+      strictSSL: flag.strictSSL,
+      proxy: flag.proxy,
+      forever: true
+    };
+
+    const preflightClient = request(preflightOptions);
+
+    preflightClient.on("response", resp => {
+      // don't send the real request if the preflight request returned an error
+      if (resp.statusCode < 200 || resp.statusCode > 299) {
+        client.emit("error", new Error("Response for preflight has invalid HTTP status code " + resp.statusCode));
+        return;
+      }
+      // don't send the real request if we aren't allowed to use the headers
+      if (!validCORSPreflightHeaders(xhr, resp, flag, properties)) {
+        setResponseToNetworkError(xhr);
+        return;
+      }
+      const realClient = doRequest();
+      realClient.on("response", res => client.emit("response", res));
+      realClient.on("data", chunk => client.emit("data", chunk));
+      realClient.on("end", () => client.emit("end"));
+      realClient.on("abort", () => client.emit("abort"));
+      realClient.on("request", req => {
+        client.headers = realClient.headers;
+        client.emit("request", req);
+      });
+      realClient.on("redirect", () => {
+        client.response = realClient.response;
+        client.emit("redirect");
+      });
+      realClient.on("error", err => client.emit("error", err));
+      client.abort = () => {
+        realClient.abort();
+      };
+    });
+
+    preflightClient.on("error", err => client.emit("error", err));
+
+    client.abort = () => {
+      preflightClient.abort();
+    };
+  } else {
+    client = doRequest();
+  }
+
+  if (requestManager) {
+    const req = {
+      abort() {
+        properties.abortError = true;
+        xhr.abort();
+      }
+    };
+    requestManager.add(req);
+    const rmReq = requestManager.remove.bind(requestManager, req);
+    client.on("abort", rmReq);
+    client.on("error", rmReq);
+    client.on("end", rmReq);
+  }
+
+  return client;
+}
+
+exports.headerListSeparatorRegexp = headerListSeparatorRegexp;
+exports.simpleHeaders = simpleHeaders;
+exports.preflightHeaders = preflightHeaders;
+exports.getRequestHeader = getRequestHeader;
+exports.updateRequestHeader = updateRequestHeader;
+exports.dispatchError = dispatchError;
+exports.validCORSHeaders = validCORSHeaders;
+exports.requestErrorSteps = requestErrorSteps;
+exports.setResponseToNetworkError = setResponseToNetworkError;
+exports.createClient = createClient;
diff --git a/lib/jsdom/named-properties-tracker.js b/lib/jsdom/named-properties-tracker.js
new file mode 100644
index 0000000..77ba22b
--- /dev/null
+++ b/lib/jsdom/named-properties-tracker.js
@@ -0,0 +1,158 @@
+"use strict";
+// https://heycam.github.io/webidl/#idl-named-properties
+
+const IS_NAMED_PROPERTY = Symbol("is named property");
+const TRACKER = Symbol("named property tracker");
+
+/**
+ * Create a new NamedPropertiesTracker for the given `object`.
+ *
+ * Named properties are used in DOM to let you lookup (for example) a Node by accessing a property on another object.
+ * For example `window.foo` might resolve to an image element with id "foo".
+ *
+ * This tracker is a workaround because the ES6 Proxy feature is not yet available.
+ *
+ * @param {Object} object Object used to write properties to
+ * @param {Object} objectProxy Object used to check if a property is already defined
+ * @param {Function} resolverFunc Each time a property is accessed, this function is called to determine the value of
+ *        the property. The function is passed 3 arguments: (object, name, values).
+ *        `object` is identical to the `object` parameter of this `create` function.
+ *        `name` is the name of the property.
+ *        `values` is a function that returns a Set with all the tracked values for this name. The order of these
+ *        values is undefined.
+ *
+ * @returns {NamedPropertiesTracker}
+ */
+exports.create = function (object, objectProxy, resolverFunc) {
+  if (object[TRACKER]) {
+    throw Error("A NamedPropertiesTracker has already been created for this object");
+  }
+
+  const tracker = new NamedPropertiesTracker(object, objectProxy, resolverFunc);
+  object[TRACKER] = tracker;
+  return tracker;
+};
+
+exports.get = function (object) {
+  if (!object) {
+    return null;
+  }
+
+  return object[TRACKER] || null;
+};
+
+function NamedPropertiesTracker(object, objectProxy, resolverFunc) {
+  this.object = object;
+  this.objectProxy = objectProxy;
+  this.resolverFunc = resolverFunc;
+  this.trackedValues = new Map(); // Map<Set<value>>
+}
+
+function newPropertyDescriptor(tracker, name) {
+  const emptySet = new Set();
+
+  function getValues() {
+    return tracker.trackedValues.get(name) || emptySet;
+  }
+
+  const descriptor = {
+    enumerable: true,
+    configurable: true,
+    get() {
+      return tracker.resolverFunc(tracker.object, name, getValues);
+    },
+    set(value) {
+      Object.defineProperty(tracker.object, name, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value
+      });
+    }
+  };
+
+  descriptor.get[IS_NAMED_PROPERTY] = true;
+  descriptor.set[IS_NAMED_PROPERTY] = true;
+  return descriptor;
+}
+
+/**
+ * Track a value (e.g. a Node) for a specified name.
+ *
+ * Values can be tracked eagerly, which means that not all tracked values *have* to appear in the output. The resolver
+ * function that was passed to the output may filter the value.
+ *
+ * Tracking the same `name` and `value` pair multiple times has no effect
+ *
+ * @param {String} name
+ * @param {*} value
+ */
+NamedPropertiesTracker.prototype.track = function (name, value) {
+  if (name === undefined || name === null || name === "") {
+    return;
+  }
+
+  let valueSet = this.trackedValues.get(name);
+  if (!valueSet) {
+    valueSet = new Set();
+    this.trackedValues.set(name, valueSet);
+  }
+
+  valueSet.add(value);
+
+  if (name in this.objectProxy) {
+    // already added our getter or it is not a named property (e.g. "addEventListener")
+    return;
+  }
+
+  const descriptor = newPropertyDescriptor(this, name);
+  Object.defineProperty(this.object, name, descriptor);
+};
+
+/**
+ * Stop tracking a previously tracked `name` & `value` pair, see track().
+ *
+ * Untracking the same `name` and `value` pair multiple times has no effect
+ *
+ * @param {String} name
+ * @param {*} value
+ */
+NamedPropertiesTracker.prototype.untrack = function (name, value) {
+  if (name === undefined || name === null || name === "") {
+    return;
+  }
+
+  const valueSet = this.trackedValues.get(name);
+  if (!valueSet) {
+    // the value is not present
+    return;
+  }
+
+  if (!valueSet.delete(value)) {
+    // the value was not present
+    return;
+  }
+
+  if (valueSet.size === 0) {
+    this.trackedValues.delete(name);
+  }
+
+  if (valueSet.size > 0) {
+    // other values for this name are still present
+    return;
+  }
+
+  // at this point there are no more values, delete the property
+
+  const descriptor = Object.getOwnPropertyDescriptor(this.object, name);
+
+  if (!descriptor || !descriptor.get || descriptor.get[IS_NAMED_PROPERTY] !== true) {
+    // Not defined by NamedPropertyTracker
+    return;
+  }
+
+  // note: delete puts the object in dictionary mode.
+  // if this turns out to be a performance issue, maybe add:
+  // https://github.com/petkaantonov/bluebird/blob/3e36fc861ac5795193ba37935333eb6ef3716390/src/util.js#L177
+  delete this.object[name];
+};
diff --git a/lib/jsdom/utils.js b/lib/jsdom/utils.js
new file mode 100644
index 0000000..460180f
--- /dev/null
+++ b/lib/jsdom/utils.js
@@ -0,0 +1,177 @@
+"use strict";
+const path = require("path");
+const whatwgURL = require("whatwg-url");
+const { domSymbolTree } = require("./living/helpers/internal-constants");
+const SYMBOL_TREE_POSITION = require("symbol-tree").TreePosition;
+const { parseURLToResultingURLRecord } = require("./living/helpers/document-base-url");
+
+exports.toFileUrl = function (fileName) {
+  // Beyond just the `path.resolve`, this is mostly for the benefit of Windows,
+  // where we need to convert "\" to "/" and add an extra "/" prefix before the
+  // drive letter.
+  let pathname = path.resolve(process.cwd(), fileName).replace(/\\/g, "/");
+  if (pathname[0] !== "/") {
+    pathname = "/" + pathname;
+  }
+
+  // path might contain spaces, so convert those to %20
+  return "file://" + encodeURI(pathname);
+};
+
+/**
+ * Define a set of properties on an object, by copying the property descriptors
+ * from the original object.
+ *
+ * - `object` {Object} the target object
+ * - `properties` {Object} the source from which to copy property descriptors
+ */
+exports.define = function define(object, properties) {
+  for (const name of Object.getOwnPropertyNames(properties)) {
+    const propDesc = Object.getOwnPropertyDescriptor(properties, name);
+    Object.defineProperty(object, name, propDesc);
+  }
+};
+
+/**
+ * Define a list of constants on a constructor and its .prototype
+ *
+ * - `Constructor` {Function} the constructor to define the constants on
+ * - `propertyMap` {Object}  key/value map of properties to define
+ */
+exports.addConstants = function addConstants(Constructor, propertyMap) {
+  for (const property in propertyMap) {
+    const value = propertyMap[property];
+    addConstant(Constructor, property, value);
+    addConstant(Constructor.prototype, property, value);
+  }
+};
+
+function addConstant(object, property, value) {
+  Object.defineProperty(object, property, {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value
+  });
+}
+
+exports.mixin = (target, source) => {
+  const keys = Reflect.ownKeys(source);
+  for (let i = 0; i < keys.length; ++i) {
+    if (keys[i] in target) {
+      continue;
+    }
+
+    Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
+  }
+};
+
+let memoizeQueryTypeCounter = 0;
+
+/**
+ * Returns a version of a method that memoizes specific types of calls on the object
+ *
+ * - `fn` {Function} the method to be memozied
+ */
+exports.memoizeQuery = function memoizeQuery(fn) {
+  // Only memoize query functions with arity <= 2
+  if (fn.length > 2) {
+    return fn;
+  }
+
+  const type = memoizeQueryTypeCounter++;
+
+  return function () {
+    if (!this._memoizedQueries) {
+      return fn.apply(this, arguments);
+    }
+
+    if (!this._memoizedQueries[type]) {
+      this._memoizedQueries[type] = Object.create(null);
+    }
+
+    let key;
+    if (arguments.length === 1 && typeof arguments[0] === "string") {
+      key = arguments[0];
+    } else if (arguments.length === 2 && typeof arguments[0] === "string" && typeof arguments[1] === "string") {
+      key = arguments[0] + "::" + arguments[1];
+    } else {
+      return fn.apply(this, arguments);
+    }
+
+    if (!(key in this._memoizedQueries[type])) {
+      this._memoizedQueries[type][key] = fn.apply(this, arguments);
+    }
+    return this._memoizedQueries[type][key];
+  };
+};
+
+exports.reflectURLAttribute = (elementImpl, contentAttributeName) => {
+  const attributeValue = elementImpl.getAttributeNS(null, contentAttributeName);
+  if (attributeValue === null || attributeValue === "") {
+    return "";
+  }
+
+  const urlRecord = parseURLToResultingURLRecord(attributeValue, elementImpl._ownerDocument);
+  if (urlRecord === null) {
+    return attributeValue;
+  }
+  return whatwgURL.serializeURL(urlRecord);
+};
+
+function isValidAbsoluteURL(str) {
+  return whatwgURL.parseURL(str) !== null;
+}
+
+exports.isValidTargetOrigin = function (str) {
+  return str === "*" || str === "/" || isValidAbsoluteURL(str);
+};
+
+exports.simultaneousIterators = function* (first, second) {
+  for (;;) {
+    const firstResult = first.next();
+    const secondResult = second.next();
+
+    if (firstResult.done && secondResult.done) {
+      return;
+    }
+
+    yield [
+      firstResult.done ? null : firstResult.value,
+      secondResult.done ? null : secondResult.value
+    ];
+  }
+};
+
+exports.treeOrderSorter = function (a, b) {
+  const compare = domSymbolTree.compareTreePosition(a, b);
+
+  if (compare & SYMBOL_TREE_POSITION.PRECEDING) { // b is preceding a
+    return 1;
+  }
+
+  if (compare & SYMBOL_TREE_POSITION.FOLLOWING) {
+    return -1;
+  }
+
+  // disconnected or equal:
+  return 0;
+};
+
+/* eslint-disable global-require */
+
+exports.Canvas = null;
+let canvasInstalled = false;
+try {
+  require.resolve("canvas");
+  canvasInstalled = true;
+} catch (e) {
+  // canvas is not installed
+}
+if (canvasInstalled) {
+  const Canvas = require("canvas");
+  if (typeof Canvas.createCanvas === "function") {
+    // In browserify, the require will succeed but return an empty object
+    exports.Canvas = Canvas;
+  }
+}
diff --git a/lib/jsdom/virtual-console.js b/lib/jsdom/virtual-console.js
new file mode 100644
index 0000000..1e08f9f
--- /dev/null
+++ b/lib/jsdom/virtual-console.js
@@ -0,0 +1,34 @@
+"use strict";
+const { EventEmitter } = require("events");
+
+module.exports = class VirtualConsole extends EventEmitter {
+  constructor() {
+    super();
+
+    this.on("error", () => {
+      // If "error" event has no listeners,
+      // EventEmitter throws an exception
+    });
+  }
+
+  sendTo(anyConsole, options) {
+    if (options === undefined) {
+      options = {};
+    }
+
+    for (const method of Object.keys(anyConsole)) {
+      if (typeof anyConsole[method] === "function") {
+        function onMethodCall() {
+          anyConsole[method](...arguments);
+        }
+        this.on(method, onMethodCall);
+      }
+    }
+
+    if (!options.omitJSDOMErrors) {
+      this.on("jsdomError", e => anyConsole.error(e.stack, e.detail));
+    }
+
+    return this;
+  }
+};
diff --git a/lib/jsdom/vm-shim.js b/lib/jsdom/vm-shim.js
new file mode 100644
index 0000000..cea6118
--- /dev/null
+++ b/lib/jsdom/vm-shim.js
@@ -0,0 +1,126 @@
+"use strict";
+/* eslint-disable no-new-func */
+const acorn = require("acorn");
+const findGlobals = require("acorn-globals");
+const escodegen = require("escodegen");
+
+// We can't use the default browserify vm shim because it doesn't work in a web worker.
+
+// From ES spec table of contents. Also, don't forget the Annex B additions.
+// If someone feels ambitious maybe make this into an npm package.
+const builtInConsts = ["Infinity", "NaN", "undefined"];
+const otherBuiltIns = [
+  "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent",
+  "encodeURI", "encodeURIComponent", "Array", "ArrayBuffer", "Boolean", "DataView", "Date", "Error", "EvalError",
+  "Float32Array", "Float64Array", "Function", "Int8Array", "Int16Array", "Int32Array", "Map", "Number", "Object",
+  "Proxy", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "Symbol", "SyntaxError", "TypeError",
+  "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "URIError", "WeakMap", "WeakSet", "JSON", "Math",
+  "Reflect", "escape", "unescape"
+];
+
+exports.createContext = function (sandbox) {
+  Object.defineProperty(sandbox, "__isVMShimContext", {
+    value: true,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+
+  for (const builtIn of builtInConsts) {
+    Object.defineProperty(sandbox, builtIn, {
+      value: global[builtIn],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+
+  for (const builtIn of otherBuiltIns) {
+    Object.defineProperty(sandbox, builtIn, {
+      value: global[builtIn],
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+
+  Object.defineProperty(sandbox, "eval", {
+    value(code) {
+      return exports.runInContext(code, sandbox);
+    },
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+};
+
+exports.isContext = function (sandbox) {
+  return sandbox.__isVMShimContext;
+};
+
+exports.runInContext = function (code, contextifiedSandbox, options) {
+  if (code === "this") {
+    // Special case for during window creation.
+    return contextifiedSandbox;
+  }
+
+  if (options === undefined) {
+    options = {};
+  }
+
+  const comments = [];
+  const tokens = [];
+  const ast = acorn.parse(code, {
+    allowReturnOutsideFunction: true,
+    ranges: true,
+    // collect comments in Esprima's format
+    onComment: comments,
+    // collect token ranges
+    onToken: tokens
+  });
+
+  // make sure we keep comments
+  escodegen.attachComments(ast, comments, tokens);
+
+  const globals = findGlobals(ast);
+  for (let i = 0; i < globals.length; ++i) {
+    if (globals[i].name === "window" || globals[i].name === "this") {
+      continue;
+    }
+
+    const { nodes } = globals[i];
+    for (let j = 0; j < nodes.length; ++j) {
+      const { type, name } = nodes[j];
+      nodes[j].type = "MemberExpression";
+      nodes[j].property = { name, type };
+      nodes[j].computed = false;
+      nodes[j].object = {
+        name: "window",
+        type: "Identifier"
+      };
+    }
+  }
+
+  const lastNode = ast.body[ast.body.length - 1];
+  if (lastNode.type === "ExpressionStatement") {
+    lastNode.type = "ReturnStatement";
+    lastNode.argument = lastNode.expression;
+    delete lastNode.expression;
+  }
+
+  const rewrittenCode = escodegen.generate(ast, { comment: true });
+  const suffix = options.filename !== undefined ? "\n//# sourceURL=" + options.filename : "";
+
+  return Function("window", rewrittenCode + suffix).bind(contextifiedSandbox)(contextifiedSandbox);
+};
+
+exports.Script = class VMShimScript {
+  constructor(code, options) {
+    this._code = code;
+    this._options = options;
+  }
+
+  runInContext(sandbox, options) {
+    return exports.runInContext(this._code, sandbox, Object.assign({}, this._options, options));
+  }
+};
diff --git a/node_modules/acorn-globals/LICENSE b/node_modules/acorn-globals/LICENSE
new file mode 100644
index 0000000..27cc9f3
--- /dev/null
+++ b/node_modules/acorn-globals/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Forbes Lindesay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/node_modules/acorn-globals/README.md b/node_modules/acorn-globals/README.md
new file mode 100644
index 0000000..5f7326f
--- /dev/null
+++ b/node_modules/acorn-globals/README.md
@@ -0,0 +1,81 @@
+# acorn-globals
+
+Detect global variables in JavaScript using acorn
+
+[Get supported acorn-globals with the Tidelift Subscription](https://tidelift.com/subscription/pkg/npm-acorn_globals?utm_source=npm-acorn-globals&utm_medium=referral&utm_campaign=readme)
+
+[![Build Status](https://img.shields.io/travis/ForbesLindesay/acorn-globals/master.svg)](https://travis-ci.org/ForbesLindesay/acorn-globals)
+[![Dependency Status](https://img.shields.io/david/ForbesLindesay/acorn-globals.svg)](https://david-dm.org/ForbesLindesay/acorn-globals)
+[![NPM version](https://img.shields.io/npm/v/acorn-globals.svg)](https://www.npmjs.org/package/acorn-globals)
+
+## Installation
+
+    npm install acorn-globals
+
+## Usage
+
+detect.js
+
+```js
+var fs = require('fs');
+var detect = require('acorn-globals');
+
+var src = fs.readFileSync(__dirname + '/input.js', 'utf8');
+
+var scope = detect(src);
+console.dir(scope);
+```
+
+input.js
+
+```js
+var x = 5;
+var y = 3, z = 2;
+
+w.foo();
+w = 2;
+
+RAWR=444;
+RAWR.foo();
+
+BLARG=3;
+
+foo(function () {
+    var BAR = 3;
+    process.nextTick(function (ZZZZZZZZZZZZ) {
+        console.log('beep boop');
+        var xyz = 4;
+        x += 10;
+        x.zzzzzz;
+        ZZZ=6;
+    });
+    function doom () {
+    }
+    ZZZ.foo();
+
+});
+
+console.log(xyz);
+```
+
+output:
+
+```
+$ node example/detect.js
+[ { name: 'BLARG', nodes: [ [Object] ] },
+  { name: 'RAWR', nodes: [ [Object], [Object] ] },
+  { name: 'ZZZ', nodes: [ [Object], [Object] ] },
+  { name: 'console', nodes: [ [Object], [Object] ] },
+  { name: 'foo', nodes: [ [Object] ] },
+  { name: 'process', nodes: [ [Object] ] },
+  { name: 'w', nodes: [ [Object], [Object] ] },
+  { name: 'xyz', nodes: [ [Object] ] } ]
+```
+
+## Security contact information
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
+
+## License
+
+  MIT
diff --git a/node_modules/acorn-globals/index.js b/node_modules/acorn-globals/index.js
new file mode 100644
index 0000000..232cbe4
--- /dev/null
+++ b/node_modules/acorn-globals/index.js
@@ -0,0 +1,179 @@
+'use strict';
+
+var acorn = require('acorn');
+var walk = require('acorn-walk');
+
+function isScope(node) {
+  return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'ArrowFunctionExpression' || node.type === 'Program';
+}
+function isBlockScope(node) {
+  return node.type === 'BlockStatement' || isScope(node);
+}
+
+function declaresArguments(node) {
+  return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
+}
+
+function declaresThis(node) {
+  return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
+}
+
+function reallyParse(source, options) {
+  var parseOptions = Object.assign({}, options,
+    {
+      allowReturnOutsideFunction: true,
+      allowImportExportEverywhere: true,
+      allowHashBang: true
+    }
+  );
+  return acorn.parse(source, parseOptions);
+}
+module.exports = findGlobals;
+module.exports.parse = reallyParse;
+function findGlobals(source, options) {
+  options = options || {};
+  var globals = [];
+  var ast;
+  // istanbul ignore else
+  if (typeof source === 'string') {
+    ast = reallyParse(source, options);
+  } else {
+    ast = source;
+  }
+  // istanbul ignore if
+  if (!(ast && typeof ast === 'object' && ast.type === 'Program')) {
+    throw new TypeError('Source must be either a string of JavaScript or an acorn AST');
+  }
+  var declareFunction = function (node) {
+    var fn = node;
+    fn.locals = fn.locals || Object.create(null);
+    node.params.forEach(function (node) {
+      declarePattern(node, fn);
+    });
+    if (node.id) {
+      fn.locals[node.id.name] = true;
+    }
+  };
+  var declareClass = function (node) {
+    node.locals = node.locals || Object.create(null);
+    if (node.id) {
+      node.locals[node.id.name] = true;
+    }
+  };
+  var declarePattern = function (node, parent) {
+    switch (node.type) {
+      case 'Identifier':
+        parent.locals[node.name] = true;
+        break;
+      case 'ObjectPattern':
+        node.properties.forEach(function (node) {
+          declarePattern(node.value || node.argument, parent);
+        });
+        break;
+      case 'ArrayPattern':
+        node.elements.forEach(function (node) {
+          if (node) declarePattern(node, parent);
+        });
+        break;
+      case 'RestElement':
+        declarePattern(node.argument, parent);
+        break;
+      case 'AssignmentPattern':
+        declarePattern(node.left, parent);
+        break;
+      // istanbul ignore next
+      default:
+        throw new Error('Unrecognized pattern type: ' + node.type);
+    }
+  };
+  var declareModuleSpecifier = function (node, parents) {
+    ast.locals = ast.locals || Object.create(null);
+    ast.locals[node.local.name] = true;
+  };
+  walk.ancestor(ast, {
+    'VariableDeclaration': function (node, parents) {
+      var parent = null;
+      for (var i = parents.length - 1; i >= 0 && parent === null; i--) {
+        if (node.kind === 'var' ? isScope(parents[i]) : isBlockScope(parents[i])) {
+          parent = parents[i];
+        }
+      }
+      parent.locals = parent.locals || Object.create(null);
+      node.declarations.forEach(function (declaration) {
+        declarePattern(declaration.id, parent);
+      });
+    },
+    'FunctionDeclaration': function (node, parents) {
+      var parent = null;
+      for (var i = parents.length - 2; i >= 0 && parent === null; i--) {
+        if (isScope(parents[i])) {
+          parent = parents[i];
+        }
+      }
+      parent.locals = parent.locals || Object.create(null);
+      if (node.id) {
+        parent.locals[node.id.name] = true;
+      }
+      declareFunction(node);
+    },
+    'Function': declareFunction,
+    'ClassDeclaration': function (node, parents) {
+      var parent = null;
+      for (var i = parents.length - 2; i >= 0 && parent === null; i--) {
+        if (isBlockScope(parents[i])) {
+          parent = parents[i];
+        }
+      }
+      parent.locals = parent.locals || Object.create(null);
+      if (node.id) {
+        parent.locals[node.id.name] = true;
+      }
+      declareClass(node);
+    },
+    'Class': declareClass,
+    'TryStatement': function (node) {
+      if (node.handler === null) return;
+      node.handler.locals = node.handler.locals || Object.create(null);
+      declarePattern(node.handler.param, node.handler);
+    },
+    'ImportDefaultSpecifier': declareModuleSpecifier,
+    'ImportSpecifier': declareModuleSpecifier,
+    'ImportNamespaceSpecifier': declareModuleSpecifier
+  });
+  function identifier(node, parents) {
+    var name = node.name;
+    if (name === 'undefined') return;
+    for (var i = 0; i < parents.length; i++) {
+      if (name === 'arguments' && declaresArguments(parents[i])) {
+        return;
+      }
+      if (parents[i].locals && name in parents[i].locals) {
+        return;
+      }
+    }
+    node.parents = parents.slice();
+    globals.push(node);
+  }
+  walk.ancestor(ast, {
+    'VariablePattern': identifier,
+    'Identifier': identifier,
+    'ThisExpression': function (node, parents) {
+      for (var i = 0; i < parents.length; i++) {
+        if (declaresThis(parents[i])) {
+          return;
+        }
+      }
+      node.parents = parents.slice();
+      globals.push(node);
+    }
+  });
+  var groupedGlobals = Object.create(null);
+  globals.forEach(function (node) {
+    var name = node.type === 'ThisExpression' ? 'this' : node.name;
+    groupedGlobals[name] = (groupedGlobals[name] || []);
+    groupedGlobals[name].push(node);
+  });
+  return Object.keys(groupedGlobals).sort().map(function (name) {
+    return {name: name, nodes: groupedGlobals[name]};
+  });
+}
diff --git a/node_modules/acorn-globals/node_modules/.bin/acorn b/node_modules/acorn-globals/node_modules/.bin/acorn
new file mode 100755
index 0000000..cf7df46
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/.bin/acorn
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../dist/bin.js');
diff --git a/node_modules/acorn-globals/node_modules/acorn/CHANGELOG.md b/node_modules/acorn-globals/node_modules/acorn/CHANGELOG.md
new file mode 100644
index 0000000..1438da6
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/CHANGELOG.md
@@ -0,0 +1,550 @@
+## 6.4.0 (2019-11-26)
+
+### New features
+
+Add a static `acorn` property to the `Parser` class that contains the entire module interface, to allow plugins to access the instance of the library that they are acting on.
+
+## 6.3.0 (2019-08-12)
+
+### New features
+
+`sourceType: "module"` can now be used even when `ecmaVersion` is less than 6, to parse module-style code that otherwise conforms to an older standard.
+
+## 6.2.1 (2019-07-21)
+
+### Bug fixes
+
+Fix bug causing Acorn to treat some characters as identifier characters that shouldn't be treated as such.
+
+Fix issue where setting the `allowReserved` option to `"never"` allowed reserved words in some circumstances.
+
+## 6.2.0 (2019-07-04)
+
+### Bug fixes
+
+Improve valid assignment checking in `for`/`in` and `for`/`of` loops.
+
+Disallow binding `let` in patterns.
+
+### New features
+
+Support bigint syntax with `ecmaVersion` >= 10.
+
+Support dynamic `import` syntax with `ecmaVersion` >= 10.
+
+Upgrade to Unicode version 12.
+
+## 6.1.1 (2019-02-27)
+
+### Bug fixes
+
+Fix bug that caused parsing default exports of with names to fail.
+
+## 6.1.0 (2019-02-08)
+
+### Bug fixes
+
+Fix scope checking when redefining a `var` as a lexical binding.
+
+### New features
+
+Split up `parseSubscripts` to use an internal `parseSubscript` method to make it easier to extend with plugins.
+
+## 6.0.7 (2019-02-04)
+
+### Bug fixes
+
+Check that exported bindings are defined.
+
+Don't treat `\u180e` as a whitespace character.
+
+Check for duplicate parameter names in methods.
+
+Don't allow shorthand properties when they are generators or async methods.
+
+Forbid binding `await` in async arrow function's parameter list.
+
+## 6.0.6 (2019-01-30)
+
+### Bug fixes
+
+The content of class declarations and expressions is now always parsed in strict mode.
+
+Don't allow `let` or `const` to bind the variable name `let`.
+
+Treat class declarations as lexical.
+
+Don't allow a generator function declaration as the sole body of an `if` or `else`.
+
+Ignore `"use strict"` when after an empty statement.
+
+Allow string line continuations with special line terminator characters.
+
+Treat `for` bodies as part of the `for` scope when checking for conflicting bindings.
+
+Fix bug with parsing `yield` in a `for` loop initializer.
+
+Implement special cases around scope checking for functions.
+
+## 6.0.5 (2019-01-02)
+
+### Bug fixes
+
+Fix TypeScript type for `Parser.extend` and add `allowAwaitOutsideFunction` to options type.
+
+Don't treat `let` as a keyword when the next token is `{` on the next line.
+
+Fix bug that broke checking for parentheses around an object pattern in a destructuring assignment when `preserveParens` was on.
+
+## 6.0.4 (2018-11-05)
+
+### Bug fixes
+
+Further improvements to tokenizing regular expressions in corner cases.
+
+## 6.0.3 (2018-11-04)
+
+### Bug fixes
+
+Fix bug in tokenizing an expression-less return followed by a function followed by a regular expression.
+
+Remove stray symlink in the package tarball.
+
+## 6.0.2 (2018-09-26)
+
+### Bug fixes
+
+Fix bug where default expressions could fail to parse inside an object destructuring assignment expression.
+
+## 6.0.1 (2018-09-14)
+
+### Bug fixes
+
+Fix wrong value in `version` export.
+
+## 6.0.0 (2018-09-14)
+
+### Bug fixes
+
+Better handle variable-redefinition checks for catch bindings and functions directly under if statements.
+
+Forbid `new.target` in top-level arrow functions.
+
+Fix issue with parsing a regexp after `yield` in some contexts.
+
+### New features
+
+The package now comes with TypeScript definitions.
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 9 (2018).
+
+Plugins work differently, and will have to be rewritten to work with this version.
+
+The loose parser and walker have been moved into separate packages (`acorn-loose` and `acorn-walk`).
+
+## 5.7.3 (2018-09-10)
+
+### Bug fixes
+
+Fix failure to tokenize regexps after expressions like `x.of`.
+
+Better error message for unterminated template literals.
+
+## 5.7.2 (2018-08-24)
+
+### Bug fixes
+
+Properly handle `allowAwaitOutsideFunction` in for statements.
+
+Treat function declarations at the top level of modules like let bindings.
+
+Don't allow async function declarations as the only statement under a label.
+
+## 5.7.0 (2018-06-15)
+
+### New features
+
+Upgraded to Unicode 11.
+
+## 5.6.0 (2018-05-31)
+
+### New features
+
+Allow U+2028 and U+2029 in string when ECMAVersion >= 10.
+
+Allow binding-less catch statements when ECMAVersion >= 10.
+
+Add `allowAwaitOutsideFunction` option for parsing top-level `await`.
+
+## 5.5.3 (2018-03-08)
+
+### Bug fixes
+
+A _second_ republish of the code in 5.5.1, this time with yarn, to hopefully get valid timestamps.
+
+## 5.5.2 (2018-03-08)
+
+### Bug fixes
+
+A republish of the code in 5.5.1 in an attempt to solve an issue with the file timestamps in the npm package being 0.
+
+## 5.5.1 (2018-03-06)
+
+### Bug fixes
+
+Fix misleading error message for octal escapes in template strings.
+
+## 5.5.0 (2018-02-27)
+
+### New features
+
+The identifier character categorization is now based on Unicode version 10.
+
+Acorn will now validate the content of regular expressions, including new ES9 features.
+
+## 5.4.0 (2018-02-01)
+
+### Bug fixes
+
+Disallow duplicate or escaped flags on regular expressions.
+
+Disallow octal escapes in strings in strict mode.
+
+### New features
+
+Add support for async iteration.
+
+Add support for object spread and rest.
+
+## 5.3.0 (2017-12-28)
+
+### Bug fixes
+
+Fix parsing of floating point literals with leading zeroes in loose mode.
+
+Allow duplicate property names in object patterns.
+
+Don't allow static class methods named `prototype`.
+
+Disallow async functions directly under `if` or `else`.
+
+Parse right-hand-side of `for`/`of` as an assignment expression.
+
+Stricter parsing of `for`/`in`.
+
+Don't allow unicode escapes in contextual keywords.
+
+### New features
+
+Parsing class members was factored into smaller methods to allow plugins to hook into it.
+
+## 5.2.1 (2017-10-30)
+
+### Bug fixes
+
+Fix a token context corruption bug.
+
+## 5.2.0 (2017-10-30)
+
+### Bug fixes
+
+Fix token context tracking for `class` and `function` in property-name position.
+
+Make sure `%*` isn't parsed as a valid operator.
+
+Allow shorthand properties `get` and `set` to be followed by default values.
+
+Disallow `super` when not in callee or object position.
+
+### New features
+
+Support [`directive` property](https://github.com/estree/estree/compare/b3de58c9997504d6fba04b72f76e6dd1619ee4eb...1da8e603237144f44710360f8feb7a9977e905e0) on directive expression statements.
+
+## 5.1.2 (2017-09-04)
+
+### Bug fixes
+
+Disable parsing of legacy HTML-style comments in modules.
+
+Fix parsing of async methods whose names are keywords.
+
+## 5.1.1 (2017-07-06)
+
+### Bug fixes
+
+Fix problem with disambiguating regexp and division after a class.
+
+## 5.1.0 (2017-07-05)
+
+### Bug fixes
+
+Fix tokenizing of regexps in an object-desctructuring `for`/`of` loop and after `yield`.
+
+Parse zero-prefixed numbers with non-octal digits as decimal.
+
+Allow object/array patterns in rest parameters.
+
+Don't error when `yield` is used as a property name.
+
+Allow `async` as a shorthand object property.
+
+### New features
+
+Implement the [template literal revision proposal](https://github.com/tc39/proposal-template-literal-revision) for ES9.
+
+## 5.0.3 (2017-04-01)
+
+### Bug fixes
+
+Fix spurious duplicate variable definition errors for named functions.
+
+## 5.0.2 (2017-03-30)
+
+### Bug fixes
+
+A binary operator after a parenthesized arrow expression is no longer incorrectly treated as an error.
+
+## 5.0.0 (2017-03-28)
+
+### Bug fixes
+
+Raise an error for duplicated lexical bindings.
+
+Fix spurious error when an assignement expression occurred after a spread expression.
+
+Accept regular expressions after `of` (in `for`/`of`), `yield` (in a generator), and braced arrow functions.
+
+Allow labels in front or `var` declarations, even in strict mode.
+
+### Breaking changes
+
+Parse declarations following `export default` as declaration nodes, not expressions. This means that class and function declarations nodes can now have `null` as their `id`.
+
+## 4.0.11 (2017-02-07)
+
+### Bug fixes
+
+Allow all forms of member expressions to be parenthesized as lvalue.
+
+## 4.0.10 (2017-02-07)
+
+### Bug fixes
+
+Don't expect semicolons after default-exported functions or classes, even when they are expressions.
+
+Check for use of `'use strict'` directives in non-simple parameter functions, even when already in strict mode.
+
+## 4.0.9 (2017-02-06)
+
+### Bug fixes
+
+Fix incorrect error raised for parenthesized simple assignment targets, so that `(x) = 1` parses again.
+
+## 4.0.8 (2017-02-03)
+
+### Bug fixes
+
+Solve spurious parenthesized pattern errors by temporarily erring on the side of accepting programs that our delayed errors don't handle correctly yet.
+
+## 4.0.7 (2017-02-02)
+
+### Bug fixes
+
+Accept invalidly rejected code like `(x).y = 2` again.
+
+Don't raise an error when a function _inside_ strict code has a non-simple parameter list.
+
+## 4.0.6 (2017-02-02)
+
+### Bug fixes
+
+Fix exponential behavior (manifesting itself as a complete hang for even relatively small source files) introduced by the new 'use strict' check.
+
+## 4.0.5 (2017-02-02)
+
+### Bug fixes
+
+Disallow parenthesized pattern expressions.
+
+Allow keywords as export names.
+
+Don't allow the `async` keyword to be parenthesized.
+
+Properly raise an error when a keyword contains a character escape.
+
+Allow `"use strict"` to appear after other string literal expressions.
+
+Disallow labeled declarations.
+
+## 4.0.4 (2016-12-19)
+
+### Bug fixes
+
+Fix crash when `export` was followed by a keyword that can't be
+exported.
+
+## 4.0.3 (2016-08-16)
+
+### Bug fixes
+
+Allow regular function declarations inside single-statement `if` branches in loose mode. Forbid them entirely in strict mode.
+
+Properly parse properties named `async` in ES2017 mode.
+
+Fix bug where reserved words were broken in ES2017 mode.
+
+## 4.0.2 (2016-08-11)
+
+### Bug fixes
+
+Don't ignore period or 'e' characters after octal numbers.
+
+Fix broken parsing for call expressions in default parameter values of arrow functions.
+
+## 4.0.1 (2016-08-08)
+
+### Bug fixes
+
+Fix false positives in duplicated export name errors.
+
+## 4.0.0 (2016-08-07)
+
+### Breaking changes
+
+The default `ecmaVersion` option value is now 7.
+
+A number of internal method signatures changed, so plugins might need to be updated.
+
+### Bug fixes
+
+The parser now raises errors on duplicated export names.
+
+`arguments` and `eval` can now be used in shorthand properties.
+
+Duplicate parameter names in non-simple argument lists now always produce an error.
+
+### New features
+
+The `ecmaVersion` option now also accepts year-style version numbers
+(2015, etc).
+
+Support for `async`/`await` syntax when `ecmaVersion` is >= 8.
+
+Support for trailing commas in call expressions when `ecmaVersion` is >= 8.
+
+## 3.3.0 (2016-07-25)
+
+### Bug fixes
+
+Fix bug in tokenizing of regexp operator after a function declaration.
+
+Fix parser crash when parsing an array pattern with a hole.
+
+### New features
+
+Implement check against complex argument lists in functions that enable strict mode in ES7.
+
+## 3.2.0 (2016-06-07)
+
+### Bug fixes
+
+Improve handling of lack of unicode regexp support in host
+environment.
+
+Properly reject shorthand properties whose name is a keyword.
+
+### New features
+
+Visitors created with `visit.make` now have their base as _prototype_, rather than copying properties into a fresh object.
+
+## 3.1.0 (2016-04-18)
+
+### Bug fixes
+
+Properly tokenize the division operator directly after a function expression.
+
+Allow trailing comma in destructuring arrays.
+
+## 3.0.4 (2016-02-25)
+
+### Fixes
+
+Allow update expressions as left-hand-side of the ES7 exponential operator.
+
+## 3.0.2 (2016-02-10)
+
+### Fixes
+
+Fix bug that accidentally made `undefined` a reserved word when parsing ES7.
+
+## 3.0.0 (2016-02-10)
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 6 (used to be 5).
+
+Support for comprehension syntax (which was dropped from the draft spec) has been removed.
+
+### Fixes
+
+`let` and `yield` are now “contextual keywords”, meaning you can mostly use them as identifiers in ES5 non-strict code.
+
+A parenthesized class or function expression after `export default` is now parsed correctly.
+
+### New features
+
+When `ecmaVersion` is set to 7, Acorn will parse the exponentiation operator (`**`).
+
+The identifier character ranges are now based on Unicode 8.0.0.
+
+Plugins can now override the `raiseRecoverable` method to override the way non-critical errors are handled.
+
+## 2.7.0 (2016-01-04)
+
+### Fixes
+
+Stop allowing rest parameters in setters.
+
+Disallow `y` rexexp flag in ES5.
+
+Disallow `\00` and `\000` escapes in strict mode.
+
+Raise an error when an import name is a reserved word.
+
+## 2.6.2 (2015-11-10)
+
+### Fixes
+
+Don't crash when no options object is passed.
+
+## 2.6.0 (2015-11-09)
+
+### Fixes
+
+Add `await` as a reserved word in module sources.
+
+Disallow `yield` in a parameter default value for a generator.
+
+Forbid using a comma after a rest pattern in an array destructuring.
+
+### New features
+
+Support parsing stdin in command-line tool.
+
+## 2.5.0 (2015-10-27)
+
+### Fixes
+
+Fix tokenizer support in the command-line tool.
+
+Stop allowing `new.target` outside of functions.
+
+Remove legacy `guard` and `guardedHandler` properties from try nodes.
+
+Stop allowing multiple `__proto__` properties on an object literal in strict mode.
+
+Don't allow rest parameters to be non-identifier patterns.
+
+Check for duplicate paramter names in arrow functions.
diff --git a/node_modules/acorn-globals/node_modules/acorn/LICENSE b/node_modules/acorn-globals/node_modules/acorn/LICENSE
new file mode 100644
index 0000000..2c0632b
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2012-2018 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/acorn-globals/node_modules/acorn/README.md b/node_modules/acorn-globals/node_modules/acorn/README.md
new file mode 100644
index 0000000..bcf85cc
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/README.md
@@ -0,0 +1,269 @@
+# Acorn
+
+A tiny, fast JavaScript parser written in JavaScript.
+
+## Community
+
+Acorn is open source software released under an
+[MIT license](https://github.com/acornjs/acorn/blob/master/acorn/LICENSE).
+
+You are welcome to
+[report bugs](https://github.com/acornjs/acorn/issues) or create pull
+requests on [github](https://github.com/acornjs/acorn). For questions
+and discussion, please use the
+[Tern discussion forum](https://discuss.ternjs.net).
+
+## Installation
+
+The easiest way to install acorn is from [`npm`](https://www.npmjs.com/):
+
+```sh
+npm install acorn
+```
+
+Alternately, you can download the source and build acorn yourself:
+
+```sh
+git clone https://github.com/acornjs/acorn.git
+cd acorn
+npm install
+```
+
+## Interface
+
+**parse**`(input, options)` is the main interface to the library. The
+`input` parameter is a string, `options` can be undefined or an object
+setting some of the options listed below. The return value will be an
+abstract syntax tree object as specified by the [ESTree
+spec](https://github.com/estree/estree).
+
+```javascript
+let acorn = require("acorn");
+console.log(acorn.parse("1 + 1"));
+```
+
+When encountering a syntax error, the parser will raise a
+`SyntaxError` object with a meaningful message. The error object will
+have a `pos` property that indicates the string offset at which the
+error occurred, and a `loc` object that contains a `{line, column}`
+object referring to that same position.
+
+Options can be provided by passing a second argument, which should be
+an object containing any of these fields:
+
+- **ecmaVersion**: Indicates the ECMAScript version to parse. Must be
+  either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018) or 10 (2019, partial
+  support). This influences support for strict mode, the set of
+  reserved words, and support for new syntax features. Default is 9.
+
+  **NOTE**: Only 'stage 4' (finalized) ECMAScript features are being
+  implemented by Acorn. Other proposed new features can be implemented
+  through plugins.
+
+- **sourceType**: Indicate the mode the code should be parsed in. Can be
+  either `"script"` or `"module"`. This influences global strict mode
+  and parsing of `import` and `export` declarations.
+
+  **NOTE**: If set to `"module"`, then static `import` / `export` syntax
+  will be valid, even if `ecmaVersion` is less than 6.
+
+- **onInsertedSemicolon**: If given a callback, that callback will be
+  called whenever a missing semicolon is inserted by the parser. The
+  callback will be given the character offset of the point where the
+  semicolon is inserted as argument, and if `locations` is on, also a
+  `{line, column}` object representing this position.
+
+- **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
+  commas.
+
+- **allowReserved**: If `false`, using a reserved word will generate
+  an error. Defaults to `true` for `ecmaVersion` 3, `false` for higher
+  versions. When given the value `"never"`, reserved words and
+  keywords can also not be used as property names (as in Internet
+  Explorer's old parser).
+
+- **allowReturnOutsideFunction**: By default, a return statement at
+  the top level raises an error. Set this to `true` to accept such
+  code.
+
+- **allowImportExportEverywhere**: By default, `import` and `export`
+  declarations can only appear at a program's top level. Setting this
+  option to `true` allows them anywhere where a statement is allowed.
+  
+- **allowAwaitOutsideFunction**: By default, `await` expressions can
+  only appear inside `async` functions. Setting this option to
+  `true` allows to have top-level `await` expressions. They are
+  still not allowed in non-`async` functions, though.
+
+- **allowHashBang**: When this is enabled (off by default), if the
+  code starts with the characters `#!` (as in a shellscript), the
+  first line will be treated as a comment.
+
+- **locations**: When `true`, each node has a `loc` object attached
+  with `start` and `end` subobjects, each of which contains the
+  one-based line and zero-based column numbers in `{line, column}`
+  form. Default is `false`.
+
+- **onToken**: If a function is passed for this option, each found
+  token will be passed in same format as tokens returned from
+  `tokenizer().getToken()`.
+
+  If array is passed, each found token is pushed to it.
+
+  Note that you are not allowed to call the parser from the
+  callback—that will corrupt its internal state.
+
+- **onComment**: If a function is passed for this option, whenever a
+  comment is encountered the function will be called with the
+  following parameters:
+
+  - `block`: `true` if the comment is a block comment, false if it
+    is a line comment.
+  - `text`: The content of the comment.
+  - `start`: Character offset of the start of the comment.
+  - `end`: Character offset of the end of the comment.
+
+  When the `locations` options is on, the `{line, column}` locations
+  of the comment’s start and end are passed as two additional
+  parameters.
+
+  If array is passed for this option, each found comment is pushed
+  to it as object in Esprima format:
+
+  ```javascript
+  {
+    "type": "Line" | "Block",
+    "value": "comment text",
+    "start": Number,
+    "end": Number,
+    // If `locations` option is on:
+    "loc": {
+      "start": {line: Number, column: Number}
+      "end": {line: Number, column: Number}
+    },
+    // If `ranges` option is on:
+    "range": [Number, Number]
+  }
+  ```
+
+  Note that you are not allowed to call the parser from the
+  callback—that will corrupt its internal state.
+
+- **ranges**: Nodes have their start and end characters offsets
+  recorded in `start` and `end` properties (directly on the node,
+  rather than the `loc` object, which holds line/column data. To also
+  add a
+  [semi-standardized](https://bugzilla.mozilla.org/show_bug.cgi?id=745678)
+  `range` property holding a `[start, end]` array with the same
+  numbers, set the `ranges` option to `true`.
+
+- **program**: It is possible to parse multiple files into a single
+  AST by passing the tree produced by parsing the first file as the
+  `program` option in subsequent parses. This will add the toplevel
+  forms of the parsed file to the "Program" (top) node of an existing
+  parse tree.
+
+- **sourceFile**: When the `locations` option is `true`, you can pass
+  this option to add a `source` attribute in every node’s `loc`
+  object. Note that the contents of this option are not examined or
+  processed in any way; you are free to use whatever format you
+  choose.
+
+- **directSourceFile**: Like `sourceFile`, but a `sourceFile` property
+  will be added (regardless of the `location` option) directly to the
+  nodes, rather than the `loc` object.
+
+- **preserveParens**: If this option is `true`, parenthesized expressions
+  are represented by (non-standard) `ParenthesizedExpression` nodes
+  that have a single `expression` property containing the expression
+  inside parentheses.
+
+**parseExpressionAt**`(input, offset, options)` will parse a single
+expression in a string, and return its AST. It will not complain if
+there is more of the string left after the expression.
+
+**tokenizer**`(input, options)` returns an object with a `getToken`
+method that can be called repeatedly to get the next token, a `{start,
+end, type, value}` object (with added `loc` property when the
+`locations` option is enabled and `range` property when the `ranges`
+option is enabled). When the token's type is `tokTypes.eof`, you
+should stop calling the method, since it will keep returning that same
+token forever.
+
+In ES6 environment, returned result can be used as any other
+protocol-compliant iterable:
+
+```javascript
+for (let token of acorn.tokenizer(str)) {
+  // iterate over the tokens
+}
+
+// transform code to array of tokens:
+var tokens = [...acorn.tokenizer(str)];
+```
+
+**tokTypes** holds an object mapping names to the token type objects
+that end up in the `type` properties of tokens.
+
+**getLineInfo**`(input, offset)` can be used to get a `{line,
+column}` object for a given program string and offset.
+
+### The `Parser` class
+
+Instances of the **`Parser`** class contain all the state and logic
+that drives a parse. It has static methods `parse`,
+`parseExpressionAt`, and `tokenizer` that match the top-level
+functions by the same name.
+
+When extending the parser with plugins, you need to call these methods
+on the extended version of the class. To extend a parser with plugins,
+you can use its static `extend` method.
+
+```javascript
+var acorn = require("acorn");
+var jsx = require("acorn-jsx");
+var JSXParser = acorn.Parser.extend(jsx());
+JSXParser.parse("foo(<bar/>)");
+```
+
+The `extend` method takes any number of plugin values, and returns a
+new `Parser` class that includes the extra parser logic provided by
+the plugins.
+
+## Command line interface
+
+The `bin/acorn` utility can be used to parse a file from the command
+line. It accepts as arguments its input file and the following
+options:
+
+- `--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|--ecma10`: Sets the ECMAScript version
+  to parse. Default is version 9.
+
+- `--module`: Sets the parsing mode to `"module"`. Is set to `"script"` otherwise.
+
+- `--locations`: Attaches a "loc" object to each node with "start" and
+  "end" subobjects, each of which contains the one-based line and
+  zero-based column numbers in `{line, column}` form.
+
+- `--allow-hash-bang`: If the code starts with the characters #! (as
+  in a shellscript), the first line will be treated as a comment.
+
+- `--compact`: No whitespace is used in the AST output.
+
+- `--silent`: Do not output the AST, just return the exit status.
+
+- `--help`: Print the usage information and quit.
+
+The utility spits out the syntax tree as JSON data.
+
+## Existing plugins
+
+ - [`acorn-jsx`](https://github.com/RReverser/acorn-jsx): Parse [Facebook JSX syntax extensions](https://github.com/facebook/jsx)
+ 
+Plugins for ECMAScript proposals:
+ 
+ - [`acorn-stage3`](https://github.com/acornjs/acorn-stage3): Parse most stage 3 proposals, bundling:
+   - [`acorn-class-fields`](https://github.com/acornjs/acorn-class-fields): Parse [class fields proposal](https://github.com/tc39/proposal-class-fields)
+   - [`acorn-import-meta`](https://github.com/acornjs/acorn-import-meta): Parse [import.meta proposal](https://github.com/tc39/proposal-import-meta)
+   - [`acorn-numeric-separator`](https://github.com/acornjs/acorn-numeric-separator): Parse [numeric separator proposal](https://github.com/tc39/proposal-numeric-separator)
+   - [`acorn-private-methods`](https://github.com/acornjs/acorn-private-methods): parse [private methods, getters and setters proposal](https://github.com/tc39/proposal-private-methods)n
diff --git a/node_modules/acorn-globals/node_modules/acorn/bin/acorn b/node_modules/acorn-globals/node_modules/acorn/bin/acorn
new file mode 100755
index 0000000..5907b3e
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/bin/acorn
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('acorn/dist/bin.js');
diff --git a/node_modules/acorn-globals/node_modules/acorn/dist/acorn.d.ts b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.d.ts
new file mode 100644
index 0000000..c68e239
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.d.ts
@@ -0,0 +1,209 @@
+export as namespace acorn
+export = acorn
+
+declare namespace acorn {
+  function parse(input: string, options?: Options): Node
+
+  function parseExpressionAt(input: string, pos?: number, options?: Options): Node
+
+  function tokenizer(input: string, options?: Options): {
+    getToken(): Token
+    [Symbol.iterator](): Iterator<Token>
+  }
+
+  interface Options {
+    ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 9 | 10 | 2015 | 2016 | 2017 | 2018 | 2019
+    sourceType?: 'script' | 'module'
+    onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    allowReserved?: boolean | 'never'
+    allowReturnOutsideFunction?: boolean
+    allowImportExportEverywhere?: boolean
+    allowAwaitOutsideFunction?: boolean
+    allowHashBang?: boolean
+    locations?: boolean
+    onToken?: ((token: Token) => any) | Token[]
+    onComment?: ((
+      isBlock: boolean, text: string, start: number, end: number, startLoc?: Position,
+      endLoc?: Position
+    ) => void) | Comment[]
+    ranges?: boolean
+    program?: Node
+    sourceFile?: string
+    directSourceFile?: string
+    preserveParens?: boolean
+  }
+
+  class Parser {
+    constructor(options: Options, input: string, startPos?: number)
+    parse(this: Parser): Node
+    static parse(this: typeof Parser, input: string, options?: Options): Node
+    static parseExpressionAt(this: typeof Parser, input: string, pos: number, options?: Options): Node
+    static tokenizer(this: typeof Parser, input: string, options?: Options): {
+      getToken(): Token
+      [Symbol.iterator](): Iterator<Token>
+    }
+    static extend(this: typeof Parser, ...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser
+  }
+
+  interface Position { line: number; column: number; offset: number }
+
+  const defaultOptions: Options
+
+  function getLineInfo(input: string, offset: number): Position
+
+  class SourceLocation {
+    start: Position
+    end: Position
+    source?: string | null
+    constructor(p: Parser, start: Position, end: Position)
+  }
+
+  class Node {
+    type: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    sourceFile?: string
+    range?: [number, number]
+    constructor(parser: Parser, pos: number, loc?: SourceLocation)
+  }
+
+  class TokenType {
+    label: string
+    keyword: string
+    beforeExpr: boolean
+    startsExpr: boolean
+    isLoop: boolean
+    isAssign: boolean
+    prefix: boolean
+    postfix: boolean
+    binop: number
+    updateContext?: (prevType: TokenType) => void
+    constructor(label: string, conf?: any)
+  }
+
+  const tokTypes: {
+    num: TokenType
+    regexp: TokenType
+    string: TokenType
+    name: TokenType
+    eof: TokenType
+    bracketL: TokenType
+    bracketR: TokenType
+    braceL: TokenType
+    braceR: TokenType
+    parenL: TokenType
+    parenR: TokenType
+    comma: TokenType
+    semi: TokenType
+    colon: TokenType
+    dot: TokenType
+    question: TokenType
+    arrow: TokenType
+    template: TokenType
+    ellipsis: TokenType
+    backQuote: TokenType
+    dollarBraceL: TokenType
+    eq: TokenType
+    assign: TokenType
+    incDec: TokenType
+    prefix: TokenType
+    logicalOR: TokenType
+    logicalAND: TokenType
+    bitwiseOR: TokenType
+    bitwiseXOR: TokenType
+    bitwiseAND: TokenType
+    equality: TokenType
+    relational: TokenType
+    bitShift: TokenType
+    plusMin: TokenType
+    modulo: TokenType
+    star: TokenType
+    slash: TokenType
+    starstar: TokenType
+    _break: TokenType
+    _case: TokenType
+    _catch: TokenType
+    _continue: TokenType
+    _debugger: TokenType
+    _default: TokenType
+    _do: TokenType
+    _else: TokenType
+    _finally: TokenType
+    _for: TokenType
+    _function: TokenType
+    _if: TokenType
+    _return: TokenType
+    _switch: TokenType
+    _throw: TokenType
+    _try: TokenType
+    _var: TokenType
+    _const: TokenType
+    _while: TokenType
+    _with: TokenType
+    _new: TokenType
+    _this: TokenType
+    _super: TokenType
+    _class: TokenType
+    _extends: TokenType
+    _export: TokenType
+    _import: TokenType
+    _null: TokenType
+    _true: TokenType
+    _false: TokenType
+    _in: TokenType
+    _instanceof: TokenType
+    _typeof: TokenType
+    _void: TokenType
+    _delete: TokenType
+  }
+
+  class TokContext {
+    constructor(token: string, isExpr: boolean, preserveSpace: boolean, override?: (p: Parser) => void)
+  }
+
+  const tokContexts: {
+    b_stat: TokContext
+    b_expr: TokContext
+    b_tmpl: TokContext
+    p_stat: TokContext
+    p_expr: TokContext
+    q_tmpl: TokContext
+    f_expr: TokContext
+  }
+
+  function isIdentifierStart(code: number, astral?: boolean): boolean
+
+  function isIdentifierChar(code: number, astral?: boolean): boolean
+
+  interface AbstractToken {
+  }
+
+  interface Comment extends AbstractToken {
+    type: string
+    value: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+  }
+
+  class Token {
+    type: TokenType
+    value: any
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+    constructor(p: Parser)
+  }
+
+  function isNewLine(code: number): boolean
+
+  const lineBreak: RegExp
+
+  const lineBreakG: RegExp
+
+  const version: string
+}
diff --git a/node_modules/acorn-globals/node_modules/acorn/dist/acorn.js b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.js
new file mode 100644
index 0000000..52644f2
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.js
@@ -0,0 +1,4992 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.acorn = {}));
+}(this, function (exports) { 'use strict';
+
+  // Reserved word lists for various dialects of the language
+
+  var reservedWords = {
+    3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
+    5: "class enum extends super const export import",
+    6: "enum",
+    strict: "implements interface let package private protected public static yield",
+    strictBind: "eval arguments"
+  };
+
+  // And the keywords
+
+  var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
+
+  var keywords = {
+    5: ecma5AndLessKeywords,
+    "5module": ecma5AndLessKeywords + " export import",
+    6: ecma5AndLessKeywords + " const class extends export import super"
+  };
+
+  var keywordRelationalOperator = /^in(stanceof)?$/;
+
+  // ## Character categories
+
+  // Big ugly regular expressions that match characters in the
+  // whitespace, identifier, and identifier-start categories. These
+  // are only applied when a character is found to actually have a
+  // code point above 128.
+  // Generated by `bin/generate-identifier-regex.js`.
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+
+  // These are a run-length and offset encoded representation of the
+  // >0xffff code points that are a valid part of identifiers. The
+  // offset starts at 0x10000, and each pair of numbers represents an
+  // offset to the next range, and then a size of the range. They were
+  // generated by bin/generate-identifier-regex.js
+
+  // eslint-disable-next-line comma-spacing
+  var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,155,22,13,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,0,33,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,0,161,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,754,9486,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541];
+
+  // eslint-disable-next-line comma-spacing
+  var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,232,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,792487,239];
+
+  // This has a complexity linear to the value of the code. The
+  // assumption is that looking up astral identifier characters is
+  // rare.
+  function isInAstralSet(code, set) {
+    var pos = 0x10000;
+    for (var i = 0; i < set.length; i += 2) {
+      pos += set[i];
+      if (pos > code) { return false }
+      pos += set[i + 1];
+      if (pos >= code) { return true }
+    }
+  }
+
+  // Test whether a given character code starts an identifier.
+
+  function isIdentifierStart(code, astral) {
+    if (code < 65) { return code === 36 }
+    if (code < 91) { return true }
+    if (code < 97) { return code === 95 }
+    if (code < 123) { return true }
+    if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
+    if (astral === false) { return false }
+    return isInAstralSet(code, astralIdentifierStartCodes)
+  }
+
+  // Test whether a given character is part of an identifier.
+
+  function isIdentifierChar(code, astral) {
+    if (code < 48) { return code === 36 }
+    if (code < 58) { return true }
+    if (code < 65) { return false }
+    if (code < 91) { return true }
+    if (code < 97) { return code === 95 }
+    if (code < 123) { return true }
+    if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
+    if (astral === false) { return false }
+    return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
+  }
+
+  // ## Token types
+
+  // The assignment of fine-grained, information-carrying type objects
+  // allows the tokenizer to store the information it has about a
+  // token in a way that is very cheap for the parser to look up.
+
+  // All token type variables start with an underscore, to make them
+  // easy to recognize.
+
+  // The `beforeExpr` property is used to disambiguate between regular
+  // expressions and divisions. It is set on all token types that can
+  // be followed by an expression (thus, a slash after them would be a
+  // regular expression).
+  //
+  // The `startsExpr` property is used to check if the token ends a
+  // `yield` expression. It is set on all token types that either can
+  // directly start an expression (like a quotation mark) or can
+  // continue an expression (like the body of a string).
+  //
+  // `isLoop` marks a keyword as starting a loop, which is important
+  // to know when parsing a label, in order to allow or disallow
+  // continue jumps to that label.
+
+  var TokenType = function TokenType(label, conf) {
+    if ( conf === void 0 ) conf = {};
+
+    this.label = label;
+    this.keyword = conf.keyword;
+    this.beforeExpr = !!conf.beforeExpr;
+    this.startsExpr = !!conf.startsExpr;
+    this.isLoop = !!conf.isLoop;
+    this.isAssign = !!conf.isAssign;
+    this.prefix = !!conf.prefix;
+    this.postfix = !!conf.postfix;
+    this.binop = conf.binop || null;
+    this.updateContext = null;
+  };
+
+  function binop(name, prec) {
+    return new TokenType(name, {beforeExpr: true, binop: prec})
+  }
+  var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};
+
+  // Map keyword names to token types.
+
+  var keywords$1 = {};
+
+  // Succinct definitions of keyword token types
+  function kw(name, options) {
+    if ( options === void 0 ) options = {};
+
+    options.keyword = name;
+    return keywords$1[name] = new TokenType(name, options)
+  }
+
+  var types = {
+    num: new TokenType("num", startsExpr),
+    regexp: new TokenType("regexp", startsExpr),
+    string: new TokenType("string", startsExpr),
+    name: new TokenType("name", startsExpr),
+    eof: new TokenType("eof"),
+
+    // Punctuation token types.
+    bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
+    bracketR: new TokenType("]"),
+    braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
+    braceR: new TokenType("}"),
+    parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
+    parenR: new TokenType(")"),
+    comma: new TokenType(",", beforeExpr),
+    semi: new TokenType(";", beforeExpr),
+    colon: new TokenType(":", beforeExpr),
+    dot: new TokenType("."),
+    question: new TokenType("?", beforeExpr),
+    arrow: new TokenType("=>", beforeExpr),
+    template: new TokenType("template"),
+    invalidTemplate: new TokenType("invalidTemplate"),
+    ellipsis: new TokenType("...", beforeExpr),
+    backQuote: new TokenType("`", startsExpr),
+    dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
+
+    // Operators. These carry several kinds of properties to help the
+    // parser use them properly (the presence of these properties is
+    // what categorizes them as operators).
+    //
+    // `binop`, when present, specifies that this operator is a binary
+    // operator, and will refer to its precedence.
+    //
+    // `prefix` and `postfix` mark the operator as a prefix or postfix
+    // unary operator.
+    //
+    // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+    // binary operators with a very low precedence, that should result
+    // in AssignmentExpression nodes.
+
+    eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
+    assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
+    incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+    prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
+    logicalOR: binop("||", 1),
+    logicalAND: binop("&&", 2),
+    bitwiseOR: binop("|", 3),
+    bitwiseXOR: binop("^", 4),
+    bitwiseAND: binop("&", 5),
+    equality: binop("==/!=/===/!==", 6),
+    relational: binop("</>/<=/>=", 7),
+    bitShift: binop("<</>>/>>>", 8),
+    plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
+    modulo: binop("%", 10),
+    star: binop("*", 10),
+    slash: binop("/", 10),
+    starstar: new TokenType("**", {beforeExpr: true}),
+
+    // Keyword token types.
+    _break: kw("break"),
+    _case: kw("case", beforeExpr),
+    _catch: kw("catch"),
+    _continue: kw("continue"),
+    _debugger: kw("debugger"),
+    _default: kw("default", beforeExpr),
+    _do: kw("do", {isLoop: true, beforeExpr: true}),
+    _else: kw("else", beforeExpr),
+    _finally: kw("finally"),
+    _for: kw("for", {isLoop: true}),
+    _function: kw("function", startsExpr),
+    _if: kw("if"),
+    _return: kw("return", beforeExpr),
+    _switch: kw("switch"),
+    _throw: kw("throw", beforeExpr),
+    _try: kw("try"),
+    _var: kw("var"),
+    _const: kw("const"),
+    _while: kw("while", {isLoop: true}),
+    _with: kw("with"),
+    _new: kw("new", {beforeExpr: true, startsExpr: true}),
+    _this: kw("this", startsExpr),
+    _super: kw("super", startsExpr),
+    _class: kw("class", startsExpr),
+    _extends: kw("extends", beforeExpr),
+    _export: kw("export"),
+    _import: kw("import", startsExpr),
+    _null: kw("null", startsExpr),
+    _true: kw("true", startsExpr),
+    _false: kw("false", startsExpr),
+    _in: kw("in", {beforeExpr: true, binop: 7}),
+    _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
+    _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
+    _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
+    _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
+  };
+
+  // Matches a whole line break (where CRLF is considered a single
+  // line break). Used to count lines.
+
+  var lineBreak = /\r\n?|\n|\u2028|\u2029/;
+  var lineBreakG = new RegExp(lineBreak.source, "g");
+
+  function isNewLine(code, ecma2019String) {
+    return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))
+  }
+
+  var nonASCIIwhitespace = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+
+  var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+
+  var ref = Object.prototype;
+  var hasOwnProperty = ref.hasOwnProperty;
+  var toString = ref.toString;
+
+  // Checks if an object has a property.
+
+  function has(obj, propName) {
+    return hasOwnProperty.call(obj, propName)
+  }
+
+  var isArray = Array.isArray || (function (obj) { return (
+    toString.call(obj) === "[object Array]"
+  ); });
+
+  function wordsRegexp(words) {
+    return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
+  }
+
+  // These are used when `options.locations` is on, for the
+  // `startLoc` and `endLoc` properties.
+
+  var Position = function Position(line, col) {
+    this.line = line;
+    this.column = col;
+  };
+
+  Position.prototype.offset = function offset (n) {
+    return new Position(this.line, this.column + n)
+  };
+
+  var SourceLocation = function SourceLocation(p, start, end) {
+    this.start = start;
+    this.end = end;
+    if (p.sourceFile !== null) { this.source = p.sourceFile; }
+  };
+
+  // The `getLineInfo` function is mostly useful when the
+  // `locations` option is off (for performance reasons) and you
+  // want to find the line/column position for a given character
+  // offset. `input` should be the code string that the offset refers
+  // into.
+
+  function getLineInfo(input, offset) {
+    for (var line = 1, cur = 0;;) {
+      lineBreakG.lastIndex = cur;
+      var match = lineBreakG.exec(input);
+      if (match && match.index < offset) {
+        ++line;
+        cur = match.index + match[0].length;
+      } else {
+        return new Position(line, offset - cur)
+      }
+    }
+  }
+
+  // A second optional argument can be given to further configure
+  // the parser process. These options are recognized:
+
+  var defaultOptions = {
+    // `ecmaVersion` indicates the ECMAScript version to parse. Must be
+    // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10
+    // (2019). This influences support for strict mode, the set of
+    // reserved words, and support for new syntax features. The default
+    // is 9.
+    ecmaVersion: 9,
+    // `sourceType` indicates the mode the code should be parsed in.
+    // Can be either `"script"` or `"module"`. This influences global
+    // strict mode and parsing of `import` and `export` declarations.
+    sourceType: "script",
+    // `onInsertedSemicolon` can be a callback that will be called
+    // when a semicolon is automatically inserted. It will be passed
+    // the position of the comma as an offset, and if `locations` is
+    // enabled, it is given the location as a `{line, column}` object
+    // as second argument.
+    onInsertedSemicolon: null,
+    // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+    // trailing commas.
+    onTrailingComma: null,
+    // By default, reserved words are only enforced if ecmaVersion >= 5.
+    // Set `allowReserved` to a boolean value to explicitly turn this on
+    // an off. When this option has the value "never", reserved words
+    // and keywords can also not be used as property names.
+    allowReserved: null,
+    // When enabled, a return at the top level is not considered an
+    // error.
+    allowReturnOutsideFunction: false,
+    // When enabled, import/export statements are not constrained to
+    // appearing at the top of the program.
+    allowImportExportEverywhere: false,
+    // When enabled, await identifiers are allowed to appear at the top-level scope,
+    // but they are still not allowed in non-async functions.
+    allowAwaitOutsideFunction: false,
+    // When enabled, hashbang directive in the beginning of file
+    // is allowed and treated as a line comment.
+    allowHashBang: false,
+    // When `locations` is on, `loc` properties holding objects with
+    // `start` and `end` properties in `{line, column}` form (with
+    // line being 1-based and column 0-based) will be attached to the
+    // nodes.
+    locations: false,
+    // A function can be passed as `onToken` option, which will
+    // cause Acorn to call that function with object in the same
+    // format as tokens returned from `tokenizer().getToken()`. Note
+    // that you are not allowed to call the parser from the
+    // callback—that will corrupt its internal state.
+    onToken: null,
+    // A function can be passed as `onComment` option, which will
+    // cause Acorn to call that function with `(block, text, start,
+    // end)` parameters whenever a comment is skipped. `block` is a
+    // boolean indicating whether this is a block (`/* */`) comment,
+    // `text` is the content of the comment, and `start` and `end` are
+    // character offsets that denote the start and end of the comment.
+    // When the `locations` option is on, two more parameters are
+    // passed, the full `{line, column}` locations of the start and
+    // end of the comments. Note that you are not allowed to call the
+    // parser from the callback—that will corrupt its internal state.
+    onComment: null,
+    // Nodes have their start and end characters offsets recorded in
+    // `start` and `end` properties (directly on the node, rather than
+    // the `loc` object, which holds line/column data. To also add a
+    // [semi-standardized][range] `range` property holding a `[start,
+    // end]` array with the same numbers, set the `ranges` option to
+    // `true`.
+    //
+    // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+    ranges: false,
+    // It is possible to parse multiple files into a single AST by
+    // passing the tree produced by parsing the first file as
+    // `program` option in subsequent parses. This will add the
+    // toplevel forms of the parsed file to the `Program` (top) node
+    // of an existing parse tree.
+    program: null,
+    // When `locations` is on, you can pass this to record the source
+    // file in every node's `loc` object.
+    sourceFile: null,
+    // This value, if given, is stored in every node, whether
+    // `locations` is on or off.
+    directSourceFile: null,
+    // When enabled, parenthesized expressions are represented by
+    // (non-standard) ParenthesizedExpression nodes
+    preserveParens: false
+  };
+
+  // Interpret and default an options object
+
+  function getOptions(opts) {
+    var options = {};
+
+    for (var opt in defaultOptions)
+      { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
+
+    if (options.ecmaVersion >= 2015)
+      { options.ecmaVersion -= 2009; }
+
+    if (options.allowReserved == null)
+      { options.allowReserved = options.ecmaVersion < 5; }
+
+    if (isArray(options.onToken)) {
+      var tokens = options.onToken;
+      options.onToken = function (token) { return tokens.push(token); };
+    }
+    if (isArray(options.onComment))
+      { options.onComment = pushComment(options, options.onComment); }
+
+    return options
+  }
+
+  function pushComment(options, array) {
+    return function(block, text, start, end, startLoc, endLoc) {
+      var comment = {
+        type: block ? "Block" : "Line",
+        value: text,
+        start: start,
+        end: end
+      };
+      if (options.locations)
+        { comment.loc = new SourceLocation(this, startLoc, endLoc); }
+      if (options.ranges)
+        { comment.range = [start, end]; }
+      array.push(comment);
+    }
+  }
+
+  // Each scope gets a bitset that may contain these flags
+  var
+      SCOPE_TOP = 1,
+      SCOPE_FUNCTION = 2,
+      SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,
+      SCOPE_ASYNC = 4,
+      SCOPE_GENERATOR = 8,
+      SCOPE_ARROW = 16,
+      SCOPE_SIMPLE_CATCH = 32,
+      SCOPE_SUPER = 64,
+      SCOPE_DIRECT_SUPER = 128;
+
+  function functionFlags(async, generator) {
+    return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)
+  }
+
+  // Used in checkLVal and declareName to determine the type of a binding
+  var
+      BIND_NONE = 0, // Not a binding
+      BIND_VAR = 1, // Var-style binding
+      BIND_LEXICAL = 2, // Let- or const-style binding
+      BIND_FUNCTION = 3, // Function declaration
+      BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding
+      BIND_OUTSIDE = 5; // Special case for function names as bound inside the function
+
+  var Parser = function Parser(options, input, startPos) {
+    this.options = options = getOptions(options);
+    this.sourceFile = options.sourceFile;
+    this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
+    var reserved = "";
+    if (options.allowReserved !== true) {
+      for (var v = options.ecmaVersion;; v--)
+        { if (reserved = reservedWords[v]) { break } }
+      if (options.sourceType === "module") { reserved += " await"; }
+    }
+    this.reservedWords = wordsRegexp(reserved);
+    var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
+    this.reservedWordsStrict = wordsRegexp(reservedStrict);
+    this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords.strictBind);
+    this.input = String(input);
+
+    // Used to signal to callers of `readWord1` whether the word
+    // contained any escape sequences. This is needed because words with
+    // escape sequences must not be interpreted as keywords.
+    this.containsEsc = false;
+
+    // Set up token state
+
+    // The current position of the tokenizer in the input.
+    if (startPos) {
+      this.pos = startPos;
+      this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
+      this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+    } else {
+      this.pos = this.lineStart = 0;
+      this.curLine = 1;
+    }
+
+    // Properties of the current token:
+    // Its type
+    this.type = types.eof;
+    // For tokens that include more information than their type, the value
+    this.value = null;
+    // Its start and end offset
+    this.start = this.end = this.pos;
+    // And, if locations are used, the {line, column} object
+    // corresponding to those offsets
+    this.startLoc = this.endLoc = this.curPosition();
+
+    // Position information for the previous token
+    this.lastTokEndLoc = this.lastTokStartLoc = null;
+    this.lastTokStart = this.lastTokEnd = this.pos;
+
+    // The context stack is used to superficially track syntactic
+    // context to predict whether a regular expression is allowed in a
+    // given position.
+    this.context = this.initialContext();
+    this.exprAllowed = true;
+
+    // Figure out if it's a module code.
+    this.inModule = options.sourceType === "module";
+    this.strict = this.inModule || this.strictDirective(this.pos);
+
+    // Used to signify the start of a potential arrow function
+    this.potentialArrowAt = -1;
+
+    // Positions to delayed-check that yield/await does not exist in default parameters.
+    this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
+    // Labels in scope.
+    this.labels = [];
+    // Thus-far undefined exports.
+    this.undefinedExports = {};
+
+    // If enabled, skip leading hashbang line.
+    if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
+      { this.skipLineComment(2); }
+
+    // Scope tracking for duplicate variable names (see scope.js)
+    this.scopeStack = [];
+    this.enterScope(SCOPE_TOP);
+
+    // For RegExp validation
+    this.regexpState = null;
+  };
+
+  var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true } };
+
+  Parser.prototype.parse = function parse () {
+    var node = this.options.program || this.startNode();
+    this.nextToken();
+    return this.parseTopLevel(node)
+  };
+
+  prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
+  prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };
+  prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };
+  prototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };
+  prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
+  prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
+
+  // Switch to a getter for 7.0.0.
+  Parser.prototype.inNonArrowFunction = function inNonArrowFunction () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };
+
+  Parser.extend = function extend () {
+      var plugins = [], len = arguments.length;
+      while ( len-- ) plugins[ len ] = arguments[ len ];
+
+    var cls = this;
+    for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); }
+    return cls
+  };
+
+  Parser.parse = function parse (input, options) {
+    return new this(options, input).parse()
+  };
+
+  Parser.parseExpressionAt = function parseExpressionAt (input, pos, options) {
+    var parser = new this(options, input, pos);
+    parser.nextToken();
+    return parser.parseExpression()
+  };
+
+  Parser.tokenizer = function tokenizer (input, options) {
+    return new this(options, input)
+  };
+
+  Object.defineProperties( Parser.prototype, prototypeAccessors );
+
+  var pp = Parser.prototype;
+
+  // ## Parser utilities
+
+  var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)")/;
+  pp.strictDirective = function(start) {
+    for (;;) {
+      // Try to find string literal.
+      skipWhiteSpace.lastIndex = start;
+      start += skipWhiteSpace.exec(this.input)[0].length;
+      var match = literal.exec(this.input.slice(start));
+      if (!match) { return false }
+      if ((match[1] || match[2]) === "use strict") { return true }
+      start += match[0].length;
+
+      // Skip semicolon, if any.
+      skipWhiteSpace.lastIndex = start;
+      start += skipWhiteSpace.exec(this.input)[0].length;
+      if (this.input[start] === ";")
+        { start++; }
+    }
+  };
+
+  // Predicate that tests whether the next token is of the given
+  // type, and if yes, consumes it as a side effect.
+
+  pp.eat = function(type) {
+    if (this.type === type) {
+      this.next();
+      return true
+    } else {
+      return false
+    }
+  };
+
+  // Tests whether parsed token is a contextual keyword.
+
+  pp.isContextual = function(name) {
+    return this.type === types.name && this.value === name && !this.containsEsc
+  };
+
+  // Consumes contextual keyword if possible.
+
+  pp.eatContextual = function(name) {
+    if (!this.isContextual(name)) { return false }
+    this.next();
+    return true
+  };
+
+  // Asserts that following token is given contextual keyword.
+
+  pp.expectContextual = function(name) {
+    if (!this.eatContextual(name)) { this.unexpected(); }
+  };
+
+  // Test whether a semicolon can be inserted at the current position.
+
+  pp.canInsertSemicolon = function() {
+    return this.type === types.eof ||
+      this.type === types.braceR ||
+      lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+  };
+
+  pp.insertSemicolon = function() {
+    if (this.canInsertSemicolon()) {
+      if (this.options.onInsertedSemicolon)
+        { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
+      return true
+    }
+  };
+
+  // Consume a semicolon, or, failing that, see if we are allowed to
+  // pretend that there is a semicolon at this position.
+
+  pp.semicolon = function() {
+    if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
+  };
+
+  pp.afterTrailingComma = function(tokType, notNext) {
+    if (this.type === tokType) {
+      if (this.options.onTrailingComma)
+        { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
+      if (!notNext)
+        { this.next(); }
+      return true
+    }
+  };
+
+  // Expect a token of a given type. If found, consume it, otherwise,
+  // raise an unexpected token error.
+
+  pp.expect = function(type) {
+    this.eat(type) || this.unexpected();
+  };
+
+  // Raise an unexpected token error.
+
+  pp.unexpected = function(pos) {
+    this.raise(pos != null ? pos : this.start, "Unexpected token");
+  };
+
+  function DestructuringErrors() {
+    this.shorthandAssign =
+    this.trailingComma =
+    this.parenthesizedAssign =
+    this.parenthesizedBind =
+    this.doubleProto =
+      -1;
+  }
+
+  pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
+    if (!refDestructuringErrors) { return }
+    if (refDestructuringErrors.trailingComma > -1)
+      { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
+    var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
+    if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
+  };
+
+  pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
+    if (!refDestructuringErrors) { return false }
+    var shorthandAssign = refDestructuringErrors.shorthandAssign;
+    var doubleProto = refDestructuringErrors.doubleProto;
+    if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
+    if (shorthandAssign >= 0)
+      { this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); }
+    if (doubleProto >= 0)
+      { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
+  };
+
+  pp.checkYieldAwaitInDefaultParams = function() {
+    if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
+      { this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
+    if (this.awaitPos)
+      { this.raise(this.awaitPos, "Await expression cannot be a default value"); }
+  };
+
+  pp.isSimpleAssignTarget = function(expr) {
+    if (expr.type === "ParenthesizedExpression")
+      { return this.isSimpleAssignTarget(expr.expression) }
+    return expr.type === "Identifier" || expr.type === "MemberExpression"
+  };
+
+  var pp$1 = Parser.prototype;
+
+  // ### Statement parsing
+
+  // Parse a program. Initializes the parser, reads any number of
+  // statements, and wraps them in a Program node.  Optionally takes a
+  // `program` argument.  If present, the statements will be appended
+  // to its body instead of creating a new node.
+
+  pp$1.parseTopLevel = function(node) {
+    var exports = {};
+    if (!node.body) { node.body = []; }
+    while (this.type !== types.eof) {
+      var stmt = this.parseStatement(null, true, exports);
+      node.body.push(stmt);
+    }
+    if (this.inModule)
+      { for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1)
+        {
+          var name = list[i];
+
+          this.raiseRecoverable(this.undefinedExports[name].start, ("Export '" + name + "' is not defined"));
+        } }
+    this.adaptDirectivePrologue(node.body);
+    this.next();
+    node.sourceType = this.options.sourceType;
+    return this.finishNode(node, "Program")
+  };
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  pp$1.isLet = function(context) {
+    if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
+    skipWhiteSpace.lastIndex = this.pos;
+    var skip = skipWhiteSpace.exec(this.input);
+    var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+    // For ambiguous cases, determine if a LexicalDeclaration (or only a
+    // Statement) is allowed here. If context is not empty then only a Statement
+    // is allowed. However, `let [` is an explicit negative lookahead for
+    // ExpressionStatement, so special-case it first.
+    if (nextCh === 91) { return true } // '['
+    if (context) { return false }
+
+    if (nextCh === 123) { return true } // '{'
+    if (isIdentifierStart(nextCh, true)) {
+      var pos = next + 1;
+      while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }
+      var ident = this.input.slice(next, pos);
+      if (!keywordRelationalOperator.test(ident)) { return true }
+    }
+    return false
+  };
+
+  // check 'async [no LineTerminator here] function'
+  // - 'async /*foo*/ function' is OK.
+  // - 'async /*\n*/ function' is invalid.
+  pp$1.isAsyncFunction = function() {
+    if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
+      { return false }
+
+    skipWhiteSpace.lastIndex = this.pos;
+    var skip = skipWhiteSpace.exec(this.input);
+    var next = this.pos + skip[0].length;
+    return !lineBreak.test(this.input.slice(this.pos, next)) &&
+      this.input.slice(next, next + 8) === "function" &&
+      (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
+  };
+
+  // Parse a single statement.
+  //
+  // If expecting a statement and finding a slash operator, parse a
+  // regular expression literal. This is to handle cases like
+  // `if (foo) /blah/.exec(foo)`, where looking at the previous token
+  // does not help.
+
+  pp$1.parseStatement = function(context, topLevel, exports) {
+    var starttype = this.type, node = this.startNode(), kind;
+
+    if (this.isLet(context)) {
+      starttype = types._var;
+      kind = "let";
+    }
+
+    // Most types of statements are recognized by the keyword they
+    // start with. Many are trivial to parse, some require a bit of
+    // complexity.
+
+    switch (starttype) {
+    case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+    case types._debugger: return this.parseDebuggerStatement(node)
+    case types._do: return this.parseDoStatement(node)
+    case types._for: return this.parseForStatement(node)
+    case types._function:
+      // Function as sole body of either an if statement or a labeled statement
+      // works, but not when it is part of a labeled statement that is the sole
+      // body of an if statement.
+      if ((context && (this.strict || context !== "if" && context !== "label")) && this.options.ecmaVersion >= 6) { this.unexpected(); }
+      return this.parseFunctionStatement(node, false, !context)
+    case types._class:
+      if (context) { this.unexpected(); }
+      return this.parseClass(node, true)
+    case types._if: return this.parseIfStatement(node)
+    case types._return: return this.parseReturnStatement(node)
+    case types._switch: return this.parseSwitchStatement(node)
+    case types._throw: return this.parseThrowStatement(node)
+    case types._try: return this.parseTryStatement(node)
+    case types._const: case types._var:
+      kind = kind || this.value;
+      if (context && kind !== "var") { this.unexpected(); }
+      return this.parseVarStatement(node, kind)
+    case types._while: return this.parseWhileStatement(node)
+    case types._with: return this.parseWithStatement(node)
+    case types.braceL: return this.parseBlock(true, node)
+    case types.semi: return this.parseEmptyStatement(node)
+    case types._export:
+    case types._import:
+      if (this.options.ecmaVersion > 10 && starttype === types._import) {
+        skipWhiteSpace.lastIndex = this.pos;
+        var skip = skipWhiteSpace.exec(this.input);
+        var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+        if (nextCh === 40) // '('
+          { return this.parseExpressionStatement(node, this.parseExpression()) }
+      }
+
+      if (!this.options.allowImportExportEverywhere) {
+        if (!topLevel)
+          { this.raise(this.start, "'import' and 'export' may only appear at the top level"); }
+        if (!this.inModule)
+          { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
+      }
+      return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
+
+      // If the statement does not start with a statement keyword or a
+      // brace, it's an ExpressionStatement or LabeledStatement. We
+      // simply start parsing an expression, and afterwards, if the
+      // next token is a colon and the expression was a simple
+      // Identifier node, we switch to interpreting it as a label.
+    default:
+      if (this.isAsyncFunction()) {
+        if (context) { this.unexpected(); }
+        this.next();
+        return this.parseFunctionStatement(node, true, !context)
+      }
+
+      var maybeName = this.value, expr = this.parseExpression();
+      if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
+        { return this.parseLabeledStatement(node, maybeName, expr, context) }
+      else { return this.parseExpressionStatement(node, expr) }
+    }
+  };
+
+  pp$1.parseBreakContinueStatement = function(node, keyword) {
+    var isBreak = keyword === "break";
+    this.next();
+    if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
+    else if (this.type !== types.name) { this.unexpected(); }
+    else {
+      node.label = this.parseIdent();
+      this.semicolon();
+    }
+
+    // Verify that there is an actual destination to break or
+    // continue to.
+    var i = 0;
+    for (; i < this.labels.length; ++i) {
+      var lab = this.labels[i];
+      if (node.label == null || lab.name === node.label.name) {
+        if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
+        if (node.label && isBreak) { break }
+      }
+    }
+    if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); }
+    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+  };
+
+  pp$1.parseDebuggerStatement = function(node) {
+    this.next();
+    this.semicolon();
+    return this.finishNode(node, "DebuggerStatement")
+  };
+
+  pp$1.parseDoStatement = function(node) {
+    this.next();
+    this.labels.push(loopLabel);
+    node.body = this.parseStatement("do");
+    this.labels.pop();
+    this.expect(types._while);
+    node.test = this.parseParenExpression();
+    if (this.options.ecmaVersion >= 6)
+      { this.eat(types.semi); }
+    else
+      { this.semicolon(); }
+    return this.finishNode(node, "DoWhileStatement")
+  };
+
+  // Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+  // loop is non-trivial. Basically, we have to parse the init `var`
+  // statement or expression, disallowing the `in` operator (see
+  // the second parameter to `parseExpression`), and then check
+  // whether the next token is `in` or `of`. When there is no init
+  // part (semicolon immediately after the opening parenthesis), it
+  // is a regular `for` loop.
+
+  pp$1.parseForStatement = function(node) {
+    this.next();
+    var awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual("await")) ? this.lastTokStart : -1;
+    this.labels.push(loopLabel);
+    this.enterScope(0);
+    this.expect(types.parenL);
+    if (this.type === types.semi) {
+      if (awaitAt > -1) { this.unexpected(awaitAt); }
+      return this.parseFor(node, null)
+    }
+    var isLet = this.isLet();
+    if (this.type === types._var || this.type === types._const || isLet) {
+      var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
+      this.next();
+      this.parseVar(init$1, true, kind);
+      this.finishNode(init$1, "VariableDeclaration");
+      if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
+        if (this.options.ecmaVersion >= 9) {
+          if (this.type === types._in) {
+            if (awaitAt > -1) { this.unexpected(awaitAt); }
+          } else { node.await = awaitAt > -1; }
+        }
+        return this.parseForIn(node, init$1)
+      }
+      if (awaitAt > -1) { this.unexpected(awaitAt); }
+      return this.parseFor(node, init$1)
+    }
+    var refDestructuringErrors = new DestructuringErrors;
+    var init = this.parseExpression(true, refDestructuringErrors);
+    if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+      if (this.options.ecmaVersion >= 9) {
+        if (this.type === types._in) {
+          if (awaitAt > -1) { this.unexpected(awaitAt); }
+        } else { node.await = awaitAt > -1; }
+      }
+      this.toAssignable(init, false, refDestructuringErrors);
+      this.checkLVal(init);
+      return this.parseForIn(node, init)
+    } else {
+      this.checkExpressionErrors(refDestructuringErrors, true);
+    }
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    return this.parseFor(node, init)
+  };
+
+  pp$1.parseFunctionStatement = function(node, isAsync, declarationPosition) {
+    this.next();
+    return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
+  };
+
+  pp$1.parseIfStatement = function(node) {
+    this.next();
+    node.test = this.parseParenExpression();
+    // allow function declarations in branches, but only in non-strict mode
+    node.consequent = this.parseStatement("if");
+    node.alternate = this.eat(types._else) ? this.parseStatement("if") : null;
+    return this.finishNode(node, "IfStatement")
+  };
+
+  pp$1.parseReturnStatement = function(node) {
+    if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+      { this.raise(this.start, "'return' outside of function"); }
+    this.next();
+
+    // In `return` (and `break`/`continue`), the keywords with
+    // optional arguments, we eagerly look for a semicolon or the
+    // possibility to insert one.
+
+    if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
+    else { node.argument = this.parseExpression(); this.semicolon(); }
+    return this.finishNode(node, "ReturnStatement")
+  };
+
+  pp$1.parseSwitchStatement = function(node) {
+    this.next();
+    node.discriminant = this.parseParenExpression();
+    node.cases = [];
+    this.expect(types.braceL);
+    this.labels.push(switchLabel);
+    this.enterScope(0);
+
+    // Statements under must be grouped (by label) in SwitchCase
+    // nodes. `cur` is used to keep the node that we are currently
+    // adding statements to.
+
+    var cur;
+    for (var sawDefault = false; this.type !== types.braceR;) {
+      if (this.type === types._case || this.type === types._default) {
+        var isCase = this.type === types._case;
+        if (cur) { this.finishNode(cur, "SwitchCase"); }
+        node.cases.push(cur = this.startNode());
+        cur.consequent = [];
+        this.next();
+        if (isCase) {
+          cur.test = this.parseExpression();
+        } else {
+          if (sawDefault) { this.raiseRecoverable(this.lastTokStart, "Multiple default clauses"); }
+          sawDefault = true;
+          cur.test = null;
+        }
+        this.expect(types.colon);
+      } else {
+        if (!cur) { this.unexpected(); }
+        cur.consequent.push(this.parseStatement(null));
+      }
+    }
+    this.exitScope();
+    if (cur) { this.finishNode(cur, "SwitchCase"); }
+    this.next(); // Closing brace
+    this.labels.pop();
+    return this.finishNode(node, "SwitchStatement")
+  };
+
+  pp$1.parseThrowStatement = function(node) {
+    this.next();
+    if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
+      { this.raise(this.lastTokEnd, "Illegal newline after throw"); }
+    node.argument = this.parseExpression();
+    this.semicolon();
+    return this.finishNode(node, "ThrowStatement")
+  };
+
+  // Reused empty array added for node fields that are always empty.
+
+  var empty = [];
+
+  pp$1.parseTryStatement = function(node) {
+    this.next();
+    node.block = this.parseBlock();
+    node.handler = null;
+    if (this.type === types._catch) {
+      var clause = this.startNode();
+      this.next();
+      if (this.eat(types.parenL)) {
+        clause.param = this.parseBindingAtom();
+        var simple = clause.param.type === "Identifier";
+        this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
+        this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
+        this.expect(types.parenR);
+      } else {
+        if (this.options.ecmaVersion < 10) { this.unexpected(); }
+        clause.param = null;
+        this.enterScope(0);
+      }
+      clause.body = this.parseBlock(false);
+      this.exitScope();
+      node.handler = this.finishNode(clause, "CatchClause");
+    }
+    node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
+    if (!node.handler && !node.finalizer)
+      { this.raise(node.start, "Missing catch or finally clause"); }
+    return this.finishNode(node, "TryStatement")
+  };
+
+  pp$1.parseVarStatement = function(node, kind) {
+    this.next();
+    this.parseVar(node, false, kind);
+    this.semicolon();
+    return this.finishNode(node, "VariableDeclaration")
+  };
+
+  pp$1.parseWhileStatement = function(node) {
+    this.next();
+    node.test = this.parseParenExpression();
+    this.labels.push(loopLabel);
+    node.body = this.parseStatement("while");
+    this.labels.pop();
+    return this.finishNode(node, "WhileStatement")
+  };
+
+  pp$1.parseWithStatement = function(node) {
+    if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
+    this.next();
+    node.object = this.parseParenExpression();
+    node.body = this.parseStatement("with");
+    return this.finishNode(node, "WithStatement")
+  };
+
+  pp$1.parseEmptyStatement = function(node) {
+    this.next();
+    return this.finishNode(node, "EmptyStatement")
+  };
+
+  pp$1.parseLabeledStatement = function(node, maybeName, expr, context) {
+    for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1)
+      {
+      var label = list[i$1];
+
+      if (label.name === maybeName)
+        { this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+    } }
+    var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
+    for (var i = this.labels.length - 1; i >= 0; i--) {
+      var label$1 = this.labels[i];
+      if (label$1.statementStart === node.start) {
+        // Update information about previous labels on this node
+        label$1.statementStart = this.start;
+        label$1.kind = kind;
+      } else { break }
+    }
+    this.labels.push({name: maybeName, kind: kind, statementStart: this.start});
+    node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+    this.labels.pop();
+    node.label = expr;
+    return this.finishNode(node, "LabeledStatement")
+  };
+
+  pp$1.parseExpressionStatement = function(node, expr) {
+    node.expression = expr;
+    this.semicolon();
+    return this.finishNode(node, "ExpressionStatement")
+  };
+
+  // Parse a semicolon-enclosed block of statements, handling `"use
+  // strict"` declarations when `allowStrict` is true (used for
+  // function bodies).
+
+  pp$1.parseBlock = function(createNewLexicalScope, node) {
+    if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
+    if ( node === void 0 ) node = this.startNode();
+
+    node.body = [];
+    this.expect(types.braceL);
+    if (createNewLexicalScope) { this.enterScope(0); }
+    while (!this.eat(types.braceR)) {
+      var stmt = this.parseStatement(null);
+      node.body.push(stmt);
+    }
+    if (createNewLexicalScope) { this.exitScope(); }
+    return this.finishNode(node, "BlockStatement")
+  };
+
+  // Parse a regular `for` loop. The disambiguation code in
+  // `parseStatement` will already have parsed the init statement or
+  // expression.
+
+  pp$1.parseFor = function(node, init) {
+    node.init = init;
+    this.expect(types.semi);
+    node.test = this.type === types.semi ? null : this.parseExpression();
+    this.expect(types.semi);
+    node.update = this.type === types.parenR ? null : this.parseExpression();
+    this.expect(types.parenR);
+    node.body = this.parseStatement("for");
+    this.exitScope();
+    this.labels.pop();
+    return this.finishNode(node, "ForStatement")
+  };
+
+  // Parse a `for`/`in` and `for`/`of` loop, which are almost
+  // same from parser's perspective.
+
+  pp$1.parseForIn = function(node, init) {
+    var isForIn = this.type === types._in;
+    this.next();
+
+    if (
+      init.type === "VariableDeclaration" &&
+      init.declarations[0].init != null &&
+      (
+        !isForIn ||
+        this.options.ecmaVersion < 8 ||
+        this.strict ||
+        init.kind !== "var" ||
+        init.declarations[0].id.type !== "Identifier"
+      )
+    ) {
+      this.raise(
+        init.start,
+        ((isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer")
+      );
+    } else if (init.type === "AssignmentPattern") {
+      this.raise(init.start, "Invalid left-hand side in for-loop");
+    }
+    node.left = init;
+    node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
+    this.expect(types.parenR);
+    node.body = this.parseStatement("for");
+    this.exitScope();
+    this.labels.pop();
+    return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement")
+  };
+
+  // Parse a list of variable declarations.
+
+  pp$1.parseVar = function(node, isFor, kind) {
+    node.declarations = [];
+    node.kind = kind;
+    for (;;) {
+      var decl = this.startNode();
+      this.parseVarId(decl, kind);
+      if (this.eat(types.eq)) {
+        decl.init = this.parseMaybeAssign(isFor);
+      } else if (kind === "const" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+        this.unexpected();
+      } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types._in || this.isContextual("of")))) {
+        this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
+      } else {
+        decl.init = null;
+      }
+      node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+      if (!this.eat(types.comma)) { break }
+    }
+    return node
+  };
+
+  pp$1.parseVarId = function(decl, kind) {
+    decl.id = this.parseBindingAtom();
+    this.checkLVal(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
+  };
+
+  var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
+
+  // Parse a function declaration or literal (depending on the
+  // `statement & FUNC_STATEMENT`).
+
+  // Remove `allowExpressionBody` for 7.0.0, as it is only called with false
+  pp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync) {
+    this.initFunction(node);
+    if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
+      if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))
+        { this.unexpected(); }
+      node.generator = this.eat(types.star);
+    }
+    if (this.options.ecmaVersion >= 8)
+      { node.async = !!isAsync; }
+
+    if (statement & FUNC_STATEMENT) {
+      node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();
+      if (node.id && !(statement & FUNC_HANGING_STATEMENT))
+        // If it is a regular function declaration in sloppy mode, then it is
+        // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
+        // mode depends on properties of the current scope (see
+        // treatFunctionsAsVar).
+        { this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }
+    }
+
+    var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    this.awaitIdentPos = 0;
+    this.enterScope(functionFlags(node.async, node.generator));
+
+    if (!(statement & FUNC_STATEMENT))
+      { node.id = this.type === types.name ? this.parseIdent() : null; }
+
+    this.parseFunctionParams(node);
+    this.parseFunctionBody(node, allowExpressionBody, false);
+
+    this.yieldPos = oldYieldPos;
+    this.awaitPos = oldAwaitPos;
+    this.awaitIdentPos = oldAwaitIdentPos;
+    return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
+  };
+
+  pp$1.parseFunctionParams = function(node) {
+    this.expect(types.parenL);
+    node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+    this.checkYieldAwaitInDefaultParams();
+  };
+
+  // Parse a class declaration or literal (depending on the
+  // `isStatement` parameter).
+
+  pp$1.parseClass = function(node, isStatement) {
+    this.next();
+
+    // ecma-262 14.6 Class Definitions
+    // A class definition is always strict mode code.
+    var oldStrict = this.strict;
+    this.strict = true;
+
+    this.parseClassId(node, isStatement);
+    this.parseClassSuper(node);
+    var classBody = this.startNode();
+    var hadConstructor = false;
+    classBody.body = [];
+    this.expect(types.braceL);
+    while (!this.eat(types.braceR)) {
+      var element = this.parseClassElement(node.superClass !== null);
+      if (element) {
+        classBody.body.push(element);
+        if (element.type === "MethodDefinition" && element.kind === "constructor") {
+          if (hadConstructor) { this.raise(element.start, "Duplicate constructor in the same class"); }
+          hadConstructor = true;
+        }
+      }
+    }
+    node.body = this.finishNode(classBody, "ClassBody");
+    this.strict = oldStrict;
+    return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+  };
+
+  pp$1.parseClassElement = function(constructorAllowsSuper) {
+    var this$1 = this;
+
+    if (this.eat(types.semi)) { return null }
+
+    var method = this.startNode();
+    var tryContextual = function (k, noLineBreak) {
+      if ( noLineBreak === void 0 ) noLineBreak = false;
+
+      var start = this$1.start, startLoc = this$1.startLoc;
+      if (!this$1.eatContextual(k)) { return false }
+      if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
+      if (method.key) { this$1.unexpected(); }
+      method.computed = false;
+      method.key = this$1.startNodeAt(start, startLoc);
+      method.key.name = k;
+      this$1.finishNode(method.key, "Identifier");
+      return false
+    };
+
+    method.kind = "method";
+    method.static = tryContextual("static");
+    var isGenerator = this.eat(types.star);
+    var isAsync = false;
+    if (!isGenerator) {
+      if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+        isAsync = true;
+        isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+      } else if (tryContextual("get")) {
+        method.kind = "get";
+      } else if (tryContextual("set")) {
+        method.kind = "set";
+      }
+    }
+    if (!method.key) { this.parsePropertyName(method); }
+    var key = method.key;
+    var allowsDirectSuper = false;
+    if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
+        key.type === "Literal" && key.value === "constructor")) {
+      if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
+      if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
+      if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
+      method.kind = "constructor";
+      allowsDirectSuper = constructorAllowsSuper;
+    } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
+      this.raise(key.start, "Classes may not have a static property named prototype");
+    }
+    this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);
+    if (method.kind === "get" && method.value.params.length !== 0)
+      { this.raiseRecoverable(method.value.start, "getter should have no params"); }
+    if (method.kind === "set" && method.value.params.length !== 1)
+      { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
+    if (method.kind === "set" && method.value.params[0].type === "RestElement")
+      { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
+    return method
+  };
+
+  pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+    method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+    return this.finishNode(method, "MethodDefinition")
+  };
+
+  pp$1.parseClassId = function(node, isStatement) {
+    if (this.type === types.name) {
+      node.id = this.parseIdent();
+      if (isStatement)
+        { this.checkLVal(node.id, BIND_LEXICAL, false); }
+    } else {
+      if (isStatement === true)
+        { this.unexpected(); }
+      node.id = null;
+    }
+  };
+
+  pp$1.parseClassSuper = function(node) {
+    node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
+  };
+
+  // Parses module export declaration.
+
+  pp$1.parseExport = function(node, exports) {
+    this.next();
+    // export * from '...'
+    if (this.eat(types.star)) {
+      this.expectContextual("from");
+      if (this.type !== types.string) { this.unexpected(); }
+      node.source = this.parseExprAtom();
+      this.semicolon();
+      return this.finishNode(node, "ExportAllDeclaration")
+    }
+    if (this.eat(types._default)) { // export default ...
+      this.checkExport(exports, "default", this.lastTokStart);
+      var isAsync;
+      if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
+        var fNode = this.startNode();
+        this.next();
+        if (isAsync) { this.next(); }
+        node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+      } else if (this.type === types._class) {
+        var cNode = this.startNode();
+        node.declaration = this.parseClass(cNode, "nullableID");
+      } else {
+        node.declaration = this.parseMaybeAssign();
+        this.semicolon();
+      }
+      return this.finishNode(node, "ExportDefaultDeclaration")
+    }
+    // export var|const|let|function|class ...
+    if (this.shouldParseExportStatement()) {
+      node.declaration = this.parseStatement(null);
+      if (node.declaration.type === "VariableDeclaration")
+        { this.checkVariableExport(exports, node.declaration.declarations); }
+      else
+        { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
+      node.specifiers = [];
+      node.source = null;
+    } else { // export { x, y as z } [from '...']
+      node.declaration = null;
+      node.specifiers = this.parseExportSpecifiers(exports);
+      if (this.eatContextual("from")) {
+        if (this.type !== types.string) { this.unexpected(); }
+        node.source = this.parseExprAtom();
+      } else {
+        for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+          // check for keywords used as local names
+          var spec = list[i];
+
+          this.checkUnreserved(spec.local);
+          // check if export is defined
+          this.checkLocalExport(spec.local);
+        }
+
+        node.source = null;
+      }
+      this.semicolon();
+    }
+    return this.finishNode(node, "ExportNamedDeclaration")
+  };
+
+  pp$1.checkExport = function(exports, name, pos) {
+    if (!exports) { return }
+    if (has(exports, name))
+      { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
+    exports[name] = true;
+  };
+
+  pp$1.checkPatternExport = function(exports, pat) {
+    var type = pat.type;
+    if (type === "Identifier")
+      { this.checkExport(exports, pat.name, pat.start); }
+    else if (type === "ObjectPattern")
+      { for (var i = 0, list = pat.properties; i < list.length; i += 1)
+        {
+          var prop = list[i];
+
+          this.checkPatternExport(exports, prop);
+        } }
+    else if (type === "ArrayPattern")
+      { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
+        var elt = list$1[i$1];
+
+          if (elt) { this.checkPatternExport(exports, elt); }
+      } }
+    else if (type === "Property")
+      { this.checkPatternExport(exports, pat.value); }
+    else if (type === "AssignmentPattern")
+      { this.checkPatternExport(exports, pat.left); }
+    else if (type === "RestElement")
+      { this.checkPatternExport(exports, pat.argument); }
+    else if (type === "ParenthesizedExpression")
+      { this.checkPatternExport(exports, pat.expression); }
+  };
+
+  pp$1.checkVariableExport = function(exports, decls) {
+    if (!exports) { return }
+    for (var i = 0, list = decls; i < list.length; i += 1)
+      {
+      var decl = list[i];
+
+      this.checkPatternExport(exports, decl.id);
+    }
+  };
+
+  pp$1.shouldParseExportStatement = function() {
+    return this.type.keyword === "var" ||
+      this.type.keyword === "const" ||
+      this.type.keyword === "class" ||
+      this.type.keyword === "function" ||
+      this.isLet() ||
+      this.isAsyncFunction()
+  };
+
+  // Parses a comma-separated list of module exports.
+
+  pp$1.parseExportSpecifiers = function(exports) {
+    var nodes = [], first = true;
+    // export { x, y as z } [from '...']
+    this.expect(types.braceL);
+    while (!this.eat(types.braceR)) {
+      if (!first) {
+        this.expect(types.comma);
+        if (this.afterTrailingComma(types.braceR)) { break }
+      } else { first = false; }
+
+      var node = this.startNode();
+      node.local = this.parseIdent(true);
+      node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
+      this.checkExport(exports, node.exported.name, node.exported.start);
+      nodes.push(this.finishNode(node, "ExportSpecifier"));
+    }
+    return nodes
+  };
+
+  // Parses import declaration.
+
+  pp$1.parseImport = function(node) {
+    this.next();
+    // import '...'
+    if (this.type === types.string) {
+      node.specifiers = empty;
+      node.source = this.parseExprAtom();
+    } else {
+      node.specifiers = this.parseImportSpecifiers();
+      this.expectContextual("from");
+      node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
+    }
+    this.semicolon();
+    return this.finishNode(node, "ImportDeclaration")
+  };
+
+  // Parses a comma-separated list of module imports.
+
+  pp$1.parseImportSpecifiers = function() {
+    var nodes = [], first = true;
+    if (this.type === types.name) {
+      // import defaultObj, { x, y as z } from '...'
+      var node = this.startNode();
+      node.local = this.parseIdent();
+      this.checkLVal(node.local, BIND_LEXICAL);
+      nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
+      if (!this.eat(types.comma)) { return nodes }
+    }
+    if (this.type === types.star) {
+      var node$1 = this.startNode();
+      this.next();
+      this.expectContextual("as");
+      node$1.local = this.parseIdent();
+      this.checkLVal(node$1.local, BIND_LEXICAL);
+      nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
+      return nodes
+    }
+    this.expect(types.braceL);
+    while (!this.eat(types.braceR)) {
+      if (!first) {
+        this.expect(types.comma);
+        if (this.afterTrailingComma(types.braceR)) { break }
+      } else { first = false; }
+
+      var node$2 = this.startNode();
+      node$2.imported = this.parseIdent(true);
+      if (this.eatContextual("as")) {
+        node$2.local = this.parseIdent();
+      } else {
+        this.checkUnreserved(node$2.imported);
+        node$2.local = node$2.imported;
+      }
+      this.checkLVal(node$2.local, BIND_LEXICAL);
+      nodes.push(this.finishNode(node$2, "ImportSpecifier"));
+    }
+    return nodes
+  };
+
+  // Set `ExpressionStatement#directive` property for directive prologues.
+  pp$1.adaptDirectivePrologue = function(statements) {
+    for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
+      statements[i].directive = statements[i].expression.raw.slice(1, -1);
+    }
+  };
+  pp$1.isDirectiveCandidate = function(statement) {
+    return (
+      statement.type === "ExpressionStatement" &&
+      statement.expression.type === "Literal" &&
+      typeof statement.expression.value === "string" &&
+      // Reject parenthesized strings.
+      (this.input[statement.start] === "\"" || this.input[statement.start] === "'")
+    )
+  };
+
+  var pp$2 = Parser.prototype;
+
+  // Convert existing expression atom to assignable pattern
+  // if possible.
+
+  pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
+    if (this.options.ecmaVersion >= 6 && node) {
+      switch (node.type) {
+      case "Identifier":
+        if (this.inAsync && node.name === "await")
+          { this.raise(node.start, "Cannot use 'await' as identifier inside an async function"); }
+        break
+
+      case "ObjectPattern":
+      case "ArrayPattern":
+      case "RestElement":
+        break
+
+      case "ObjectExpression":
+        node.type = "ObjectPattern";
+        if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+        for (var i = 0, list = node.properties; i < list.length; i += 1) {
+          var prop = list[i];
+
+        this.toAssignable(prop, isBinding);
+          // Early error:
+          //   AssignmentRestProperty[Yield, Await] :
+          //     `...` DestructuringAssignmentTarget[Yield, Await]
+          //
+          //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.
+          if (
+            prop.type === "RestElement" &&
+            (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")
+          ) {
+            this.raise(prop.argument.start, "Unexpected token");
+          }
+        }
+        break
+
+      case "Property":
+        // AssignmentProperty has type === "Property"
+        if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
+        this.toAssignable(node.value, isBinding);
+        break
+
+      case "ArrayExpression":
+        node.type = "ArrayPattern";
+        if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+        this.toAssignableList(node.elements, isBinding);
+        break
+
+      case "SpreadElement":
+        node.type = "RestElement";
+        this.toAssignable(node.argument, isBinding);
+        if (node.argument.type === "AssignmentPattern")
+          { this.raise(node.argument.start, "Rest elements cannot have a default value"); }
+        break
+
+      case "AssignmentExpression":
+        if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); }
+        node.type = "AssignmentPattern";
+        delete node.operator;
+        this.toAssignable(node.left, isBinding);
+        // falls through to AssignmentPattern
+
+      case "AssignmentPattern":
+        break
+
+      case "ParenthesizedExpression":
+        this.toAssignable(node.expression, isBinding, refDestructuringErrors);
+        break
+
+      case "MemberExpression":
+        if (!isBinding) { break }
+
+      default:
+        this.raise(node.start, "Assigning to rvalue");
+      }
+    } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+    return node
+  };
+
+  // Convert list of expression atoms to binding list.
+
+  pp$2.toAssignableList = function(exprList, isBinding) {
+    var end = exprList.length;
+    for (var i = 0; i < end; i++) {
+      var elt = exprList[i];
+      if (elt) { this.toAssignable(elt, isBinding); }
+    }
+    if (end) {
+      var last = exprList[end - 1];
+      if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
+        { this.unexpected(last.argument.start); }
+    }
+    return exprList
+  };
+
+  // Parses spread element.
+
+  pp$2.parseSpread = function(refDestructuringErrors) {
+    var node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+    return this.finishNode(node, "SpreadElement")
+  };
+
+  pp$2.parseRestBinding = function() {
+    var node = this.startNode();
+    this.next();
+
+    // RestElement inside of a function parameter must be an identifier
+    if (this.options.ecmaVersion === 6 && this.type !== types.name)
+      { this.unexpected(); }
+
+    node.argument = this.parseBindingAtom();
+
+    return this.finishNode(node, "RestElement")
+  };
+
+  // Parses lvalue (assignable) atom.
+
+  pp$2.parseBindingAtom = function() {
+    if (this.options.ecmaVersion >= 6) {
+      switch (this.type) {
+      case types.bracketL:
+        var node = this.startNode();
+        this.next();
+        node.elements = this.parseBindingList(types.bracketR, true, true);
+        return this.finishNode(node, "ArrayPattern")
+
+      case types.braceL:
+        return this.parseObj(true)
+      }
+    }
+    return this.parseIdent()
+  };
+
+  pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+    var elts = [], first = true;
+    while (!this.eat(close)) {
+      if (first) { first = false; }
+      else { this.expect(types.comma); }
+      if (allowEmpty && this.type === types.comma) {
+        elts.push(null);
+      } else if (allowTrailingComma && this.afterTrailingComma(close)) {
+        break
+      } else if (this.type === types.ellipsis) {
+        var rest = this.parseRestBinding();
+        this.parseBindingListItem(rest);
+        elts.push(rest);
+        if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+        this.expect(close);
+        break
+      } else {
+        var elem = this.parseMaybeDefault(this.start, this.startLoc);
+        this.parseBindingListItem(elem);
+        elts.push(elem);
+      }
+    }
+    return elts
+  };
+
+  pp$2.parseBindingListItem = function(param) {
+    return param
+  };
+
+  // Parses assignment pattern around given atom if possible.
+
+  pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
+    left = left || this.parseBindingAtom();
+    if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
+    var node = this.startNodeAt(startPos, startLoc);
+    node.left = left;
+    node.right = this.parseMaybeAssign();
+    return this.finishNode(node, "AssignmentPattern")
+  };
+
+  // Verify that a node is an lval — something that can be assigned
+  // to.
+  // bindingType can be either:
+  // 'var' indicating that the lval creates a 'var' binding
+  // 'let' indicating that the lval creates a lexical ('let' or 'const') binding
+  // 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references
+
+  pp$2.checkLVal = function(expr, bindingType, checkClashes) {
+    if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+    switch (expr.type) {
+    case "Identifier":
+      if (bindingType === BIND_LEXICAL && expr.name === "let")
+        { this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name"); }
+      if (this.strict && this.reservedWordsStrictBind.test(expr.name))
+        { this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
+      if (checkClashes) {
+        if (has(checkClashes, expr.name))
+          { this.raiseRecoverable(expr.start, "Argument name clash"); }
+        checkClashes[expr.name] = true;
+      }
+      if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }
+      break
+
+    case "MemberExpression":
+      if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
+      break
+
+    case "ObjectPattern":
+      for (var i = 0, list = expr.properties; i < list.length; i += 1)
+        {
+      var prop = list[i];
+
+      this.checkLVal(prop, bindingType, checkClashes);
+    }
+      break
+
+    case "Property":
+      // AssignmentProperty has type === "Property"
+      this.checkLVal(expr.value, bindingType, checkClashes);
+      break
+
+    case "ArrayPattern":
+      for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
+        var elem = list$1[i$1];
+
+      if (elem) { this.checkLVal(elem, bindingType, checkClashes); }
+      }
+      break
+
+    case "AssignmentPattern":
+      this.checkLVal(expr.left, bindingType, checkClashes);
+      break
+
+    case "RestElement":
+      this.checkLVal(expr.argument, bindingType, checkClashes);
+      break
+
+    case "ParenthesizedExpression":
+      this.checkLVal(expr.expression, bindingType, checkClashes);
+      break
+
+    default:
+      this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
+    }
+  };
+
+  // A recursive descent parser operates by defining functions for all
+
+  var pp$3 = Parser.prototype;
+
+  // Check if property name clashes with already added.
+  // Object/class getters and setters are not allowed to clash —
+  // either with each other or with an init property — and in
+  // strict mode, init properties are also not allowed to be repeated.
+
+  pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
+    if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
+      { return }
+    if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
+      { return }
+    var key = prop.key;
+    var name;
+    switch (key.type) {
+    case "Identifier": name = key.name; break
+    case "Literal": name = String(key.value); break
+    default: return
+    }
+    var kind = prop.kind;
+    if (this.options.ecmaVersion >= 6) {
+      if (name === "__proto__" && kind === "init") {
+        if (propHash.proto) {
+          if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) { refDestructuringErrors.doubleProto = key.start; }
+          // Backwards-compat kludge. Can be removed in version 6.0
+          else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
+        }
+        propHash.proto = true;
+      }
+      return
+    }
+    name = "$" + name;
+    var other = propHash[name];
+    if (other) {
+      var redefinition;
+      if (kind === "init") {
+        redefinition = this.strict && other.init || other.get || other.set;
+      } else {
+        redefinition = other.init || other[kind];
+      }
+      if (redefinition)
+        { this.raiseRecoverable(key.start, "Redefinition of property"); }
+    } else {
+      other = propHash[name] = {
+        init: false,
+        get: false,
+        set: false
+      };
+    }
+    other[kind] = true;
+  };
+
+  // ### Expression parsing
+
+  // These nest, from the most general expression type at the top to
+  // 'atomic', nondivisible expression types at the bottom. Most of
+  // the functions will simply let the function(s) below them parse,
+  // and, *if* the syntactic construct they handle is present, wrap
+  // the AST node that the inner parser gave them in another node.
+
+  // Parse a full expression. The optional arguments are used to
+  // forbid the `in` operator (in for loops initalization expressions)
+  // and provide reference for storing '=' operator inside shorthand
+  // property assignment in contexts where both object expression
+  // and object pattern might appear (so it's possible to raise
+  // delayed syntax error at correct position).
+
+  pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+    var startPos = this.start, startLoc = this.startLoc;
+    var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
+    if (this.type === types.comma) {
+      var node = this.startNodeAt(startPos, startLoc);
+      node.expressions = [expr];
+      while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }
+      return this.finishNode(node, "SequenceExpression")
+    }
+    return expr
+  };
+
+  // Parse an assignment expression. This includes applications of
+  // operators like `+=`.
+
+  pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+    if (this.isContextual("yield")) {
+      if (this.inGenerator) { return this.parseYield(noIn) }
+      // The tokenizer will assume an expression is allowed after
+      // `yield`, but this isn't that kind of yield
+      else { this.exprAllowed = false; }
+    }
+
+    var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldShorthandAssign = -1;
+    if (refDestructuringErrors) {
+      oldParenAssign = refDestructuringErrors.parenthesizedAssign;
+      oldTrailingComma = refDestructuringErrors.trailingComma;
+      oldShorthandAssign = refDestructuringErrors.shorthandAssign;
+      refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.shorthandAssign = -1;
+    } else {
+      refDestructuringErrors = new DestructuringErrors;
+      ownDestructuringErrors = true;
+    }
+
+    var startPos = this.start, startLoc = this.startLoc;
+    if (this.type === types.parenL || this.type === types.name)
+      { this.potentialArrowAt = this.start; }
+    var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
+    if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
+    if (this.type.isAssign) {
+      var node = this.startNodeAt(startPos, startLoc);
+      node.operator = this.value;
+      node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
+      if (!ownDestructuringErrors) { DestructuringErrors.call(refDestructuringErrors); }
+      refDestructuringErrors.shorthandAssign = -1; // reset because shorthand default was used correctly
+      this.checkLVal(left);
+      this.next();
+      node.right = this.parseMaybeAssign(noIn);
+      return this.finishNode(node, "AssignmentExpression")
+    } else {
+      if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
+    }
+    if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }
+    if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }
+    if (oldShorthandAssign > -1) { refDestructuringErrors.shorthandAssign = oldShorthandAssign; }
+    return left
+  };
+
+  // Parse a ternary conditional (`?:`) operator.
+
+  pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+    var startPos = this.start, startLoc = this.startLoc;
+    var expr = this.parseExprOps(noIn, refDestructuringErrors);
+    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+    if (this.eat(types.question)) {
+      var node = this.startNodeAt(startPos, startLoc);
+      node.test = expr;
+      node.consequent = this.parseMaybeAssign();
+      this.expect(types.colon);
+      node.alternate = this.parseMaybeAssign(noIn);
+      return this.finishNode(node, "ConditionalExpression")
+    }
+    return expr
+  };
+
+  // Start the precedence parser.
+
+  pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+    var startPos = this.start, startLoc = this.startLoc;
+    var expr = this.parseMaybeUnary(refDestructuringErrors, false);
+    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+    return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+  };
+
+  // Parse binary operators with the operator precedence parsing
+  // algorithm. `left` is the left-hand side of the operator.
+  // `minPrec` provides context that allows the function to stop and
+  // defer further parser to one of its callers when it encounters an
+  // operator that has a lower precedence than the set it is parsing.
+
+  pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+    var prec = this.type.binop;
+    if (prec != null && (!noIn || this.type !== types._in)) {
+      if (prec > minPrec) {
+        var logical = this.type === types.logicalOR || this.type === types.logicalAND;
+        var op = this.value;
+        this.next();
+        var startPos = this.start, startLoc = this.startLoc;
+        var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
+        var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);
+        return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+      }
+    }
+    return left
+  };
+
+  pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.left = left;
+    node.operator = op;
+    node.right = right;
+    return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
+  };
+
+  // Parse unary operators, both prefix and postfix.
+
+  pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+    var startPos = this.start, startLoc = this.startLoc, expr;
+    if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
+      expr = this.parseAwait();
+      sawUnary = true;
+    } else if (this.type.prefix) {
+      var node = this.startNode(), update = this.type === types.incDec;
+      node.operator = this.value;
+      node.prefix = true;
+      this.next();
+      node.argument = this.parseMaybeUnary(null, true);
+      this.checkExpressionErrors(refDestructuringErrors, true);
+      if (update) { this.checkLVal(node.argument); }
+      else if (this.strict && node.operator === "delete" &&
+               node.argument.type === "Identifier")
+        { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+      else { sawUnary = true; }
+      expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+    } else {
+      expr = this.parseExprSubscripts(refDestructuringErrors);
+      if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+      while (this.type.postfix && !this.canInsertSemicolon()) {
+        var node$1 = this.startNodeAt(startPos, startLoc);
+        node$1.operator = this.value;
+        node$1.prefix = false;
+        node$1.argument = expr;
+        this.checkLVal(expr);
+        this.next();
+        expr = this.finishNode(node$1, "UpdateExpression");
+      }
+    }
+
+    if (!sawUnary && this.eat(types.starstar))
+      { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+    else
+      { return expr }
+  };
+
+  // Parse call, dot, and `[]`-subscript expressions.
+
+  pp$3.parseExprSubscripts = function(refDestructuringErrors) {
+    var startPos = this.start, startLoc = this.startLoc;
+    var expr = this.parseExprAtom(refDestructuringErrors);
+    var skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")";
+    if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) { return expr }
+    var result = this.parseSubscripts(expr, startPos, startLoc);
+    if (refDestructuringErrors && result.type === "MemberExpression") {
+      if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
+      if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+    }
+    return result
+  };
+
+  pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+    var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
+        this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
+    while (true) {
+      var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow);
+      if (element === base || element.type === "ArrowFunctionExpression") { return element }
+      base = element;
+    }
+  };
+
+  pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {
+    var computed = this.eat(types.bracketL);
+    if (computed || this.eat(types.dot)) {
+      var node = this.startNodeAt(startPos, startLoc);
+      node.object = base;
+      node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
+      node.computed = !!computed;
+      if (computed) { this.expect(types.bracketR); }
+      base = this.finishNode(node, "MemberExpression");
+    } else if (!noCalls && this.eat(types.parenL)) {
+      var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+      this.yieldPos = 0;
+      this.awaitPos = 0;
+      this.awaitIdentPos = 0;
+      var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8 && base.type !== "Import", false, refDestructuringErrors);
+      if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+        this.checkPatternErrors(refDestructuringErrors, false);
+        this.checkYieldAwaitInDefaultParams();
+        if (this.awaitIdentPos > 0)
+          { this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function"); }
+        this.yieldPos = oldYieldPos;
+        this.awaitPos = oldAwaitPos;
+        this.awaitIdentPos = oldAwaitIdentPos;
+        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)
+      }
+      this.checkExpressionErrors(refDestructuringErrors, true);
+      this.yieldPos = oldYieldPos || this.yieldPos;
+      this.awaitPos = oldAwaitPos || this.awaitPos;
+      this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;
+      var node$1 = this.startNodeAt(startPos, startLoc);
+      node$1.callee = base;
+      node$1.arguments = exprList;
+      if (node$1.callee.type === "Import") {
+        if (node$1.arguments.length !== 1) {
+          this.raise(node$1.start, "import() requires exactly one argument");
+        }
+
+        var importArg = node$1.arguments[0];
+        if (importArg && importArg.type === "SpreadElement") {
+          this.raise(importArg.start, "... is not allowed in import()");
+        }
+      }
+      base = this.finishNode(node$1, "CallExpression");
+    } else if (this.type === types.backQuote) {
+      var node$2 = this.startNodeAt(startPos, startLoc);
+      node$2.tag = base;
+      node$2.quasi = this.parseTemplate({isTagged: true});
+      base = this.finishNode(node$2, "TaggedTemplateExpression");
+    }
+    return base
+  };
+
+  // Parse an atomic expression — either a single token that is an
+  // expression, an expression started by a keyword like `function` or
+  // `new`, or an expression wrapped in punctuation like `()`, `[]`,
+  // or `{}`.
+
+  pp$3.parseExprAtom = function(refDestructuringErrors) {
+    // If a division operator appears in an expression position, the
+    // tokenizer got confused, and we force it to read a regexp instead.
+    if (this.type === types.slash) { this.readRegexp(); }
+
+    var node, canBeArrow = this.potentialArrowAt === this.start;
+    switch (this.type) {
+    case types._super:
+      if (!this.allowSuper)
+        { this.raise(this.start, "'super' keyword outside a method"); }
+      node = this.startNode();
+      this.next();
+      if (this.type === types.parenL && !this.allowDirectSuper)
+        { this.raise(node.start, "super() call outside constructor of a subclass"); }
+      // The `super` keyword can appear at below:
+      // SuperProperty:
+      //     super [ Expression ]
+      //     super . IdentifierName
+      // SuperCall:
+      //     super Arguments
+      if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
+        { this.unexpected(); }
+      return this.finishNode(node, "Super")
+
+    case types._this:
+      node = this.startNode();
+      this.next();
+      return this.finishNode(node, "ThisExpression")
+
+    case types.name:
+      var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
+      var id = this.parseIdent(false);
+      if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
+        { return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true) }
+      if (canBeArrow && !this.canInsertSemicolon()) {
+        if (this.eat(types.arrow))
+          { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
+        if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
+          id = this.parseIdent(false);
+          if (this.canInsertSemicolon() || !this.eat(types.arrow))
+            { this.unexpected(); }
+          return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
+        }
+      }
+      return id
+
+    case types.regexp:
+      var value = this.value;
+      node = this.parseLiteral(value.value);
+      node.regex = {pattern: value.pattern, flags: value.flags};
+      return node
+
+    case types.num: case types.string:
+      return this.parseLiteral(this.value)
+
+    case types._null: case types._true: case types._false:
+      node = this.startNode();
+      node.value = this.type === types._null ? null : this.type === types._true;
+      node.raw = this.type.keyword;
+      this.next();
+      return this.finishNode(node, "Literal")
+
+    case types.parenL:
+      var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
+      if (refDestructuringErrors) {
+        if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
+          { refDestructuringErrors.parenthesizedAssign = start; }
+        if (refDestructuringErrors.parenthesizedBind < 0)
+          { refDestructuringErrors.parenthesizedBind = start; }
+      }
+      return expr
+
+    case types.bracketL:
+      node = this.startNode();
+      this.next();
+      node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
+      return this.finishNode(node, "ArrayExpression")
+
+    case types.braceL:
+      return this.parseObj(false, refDestructuringErrors)
+
+    case types._function:
+      node = this.startNode();
+      this.next();
+      return this.parseFunction(node, 0)
+
+    case types._class:
+      return this.parseClass(this.startNode(), false)
+
+    case types._new:
+      return this.parseNew()
+
+    case types.backQuote:
+      return this.parseTemplate()
+
+    case types._import:
+      if (this.options.ecmaVersion > 10) {
+        return this.parseDynamicImport()
+      } else {
+        return this.unexpected()
+      }
+
+    default:
+      this.unexpected();
+    }
+  };
+
+  pp$3.parseDynamicImport = function() {
+    var node = this.startNode();
+    this.next();
+    if (this.type !== types.parenL) {
+      this.unexpected();
+    }
+    return this.finishNode(node, "Import")
+  };
+
+  pp$3.parseLiteral = function(value) {
+    var node = this.startNode();
+    node.value = value;
+    node.raw = this.input.slice(this.start, this.end);
+    if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1); }
+    this.next();
+    return this.finishNode(node, "Literal")
+  };
+
+  pp$3.parseParenExpression = function() {
+    this.expect(types.parenL);
+    var val = this.parseExpression();
+    this.expect(types.parenR);
+    return val
+  };
+
+  pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
+    var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
+    if (this.options.ecmaVersion >= 6) {
+      this.next();
+
+      var innerStartPos = this.start, innerStartLoc = this.startLoc;
+      var exprList = [], first = true, lastIsComma = false;
+      var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
+      this.yieldPos = 0;
+      this.awaitPos = 0;
+      // Do not save awaitIdentPos to allow checking awaits nested in parameters
+      while (this.type !== types.parenR) {
+        first ? first = false : this.expect(types.comma);
+        if (allowTrailingComma && this.afterTrailingComma(types.parenR, true)) {
+          lastIsComma = true;
+          break
+        } else if (this.type === types.ellipsis) {
+          spreadStart = this.start;
+          exprList.push(this.parseParenItem(this.parseRestBinding()));
+          if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+          break
+        } else {
+          exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));
+        }
+      }
+      var innerEndPos = this.start, innerEndLoc = this.startLoc;
+      this.expect(types.parenR);
+
+      if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+        this.checkPatternErrors(refDestructuringErrors, false);
+        this.checkYieldAwaitInDefaultParams();
+        this.yieldPos = oldYieldPos;
+        this.awaitPos = oldAwaitPos;
+        return this.parseParenArrowList(startPos, startLoc, exprList)
+      }
+
+      if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
+      if (spreadStart) { this.unexpected(spreadStart); }
+      this.checkExpressionErrors(refDestructuringErrors, true);
+      this.yieldPos = oldYieldPos || this.yieldPos;
+      this.awaitPos = oldAwaitPos || this.awaitPos;
+
+      if (exprList.length > 1) {
+        val = this.startNodeAt(innerStartPos, innerStartLoc);
+        val.expressions = exprList;
+        this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
+      } else {
+        val = exprList[0];
+      }
+    } else {
+      val = this.parseParenExpression();
+    }
+
+    if (this.options.preserveParens) {
+      var par = this.startNodeAt(startPos, startLoc);
+      par.expression = val;
+      return this.finishNode(par, "ParenthesizedExpression")
+    } else {
+      return val
+    }
+  };
+
+  pp$3.parseParenItem = function(item) {
+    return item
+  };
+
+  pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
+    return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
+  };
+
+  // New's precedence is slightly tricky. It must allow its argument to
+  // be a `[]` or dot subscript expression, but not a call — at least,
+  // not without wrapping it in parentheses. Thus, it uses the noCalls
+  // argument to parseSubscripts to prevent it from consuming the
+  // argument list.
+
+  var empty$1 = [];
+
+  pp$3.parseNew = function() {
+    var node = this.startNode();
+    var meta = this.parseIdent(true);
+    if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
+      node.meta = meta;
+      var containsEsc = this.containsEsc;
+      node.property = this.parseIdent(true);
+      if (node.property.name !== "target" || containsEsc)
+        { this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target"); }
+      if (!this.inNonArrowFunction())
+        { this.raiseRecoverable(node.start, "new.target can only be used in functions"); }
+      return this.finishNode(node, "MetaProperty")
+    }
+    var startPos = this.start, startLoc = this.startLoc;
+    node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
+    if (this.options.ecmaVersion > 10 && node.callee.type === "Import") {
+      this.raise(node.callee.start, "Cannot use new with import(...)");
+    }
+    if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8 && node.callee.type !== "Import", false); }
+    else { node.arguments = empty$1; }
+    return this.finishNode(node, "NewExpression")
+  };
+
+  // Parse template expression.
+
+  pp$3.parseTemplateElement = function(ref) {
+    var isTagged = ref.isTagged;
+
+    var elem = this.startNode();
+    if (this.type === types.invalidTemplate) {
+      if (!isTagged) {
+        this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
+      }
+      elem.value = {
+        raw: this.value,
+        cooked: null
+      };
+    } else {
+      elem.value = {
+        raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
+        cooked: this.value
+      };
+    }
+    this.next();
+    elem.tail = this.type === types.backQuote;
+    return this.finishNode(elem, "TemplateElement")
+  };
+
+  pp$3.parseTemplate = function(ref) {
+    if ( ref === void 0 ) ref = {};
+    var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
+
+    var node = this.startNode();
+    this.next();
+    node.expressions = [];
+    var curElt = this.parseTemplateElement({isTagged: isTagged});
+    node.quasis = [curElt];
+    while (!curElt.tail) {
+      if (this.type === types.eof) { this.raise(this.pos, "Unterminated template literal"); }
+      this.expect(types.dollarBraceL);
+      node.expressions.push(this.parseExpression());
+      this.expect(types.braceR);
+      node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged}));
+    }
+    this.next();
+    return this.finishNode(node, "TemplateLiteral")
+  };
+
+  pp$3.isAsyncProp = function(prop) {
+    return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
+      (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
+      !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+  };
+
+  // Parse an object literal or binding pattern.
+
+  pp$3.parseObj = function(isPattern, refDestructuringErrors) {
+    var node = this.startNode(), first = true, propHash = {};
+    node.properties = [];
+    this.next();
+    while (!this.eat(types.braceR)) {
+      if (!first) {
+        this.expect(types.comma);
+        if (this.afterTrailingComma(types.braceR)) { break }
+      } else { first = false; }
+
+      var prop = this.parseProperty(isPattern, refDestructuringErrors);
+      if (!isPattern) { this.checkPropClash(prop, propHash, refDestructuringErrors); }
+      node.properties.push(prop);
+    }
+    return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
+  };
+
+  pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
+    var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
+    if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
+      if (isPattern) {
+        prop.argument = this.parseIdent(false);
+        if (this.type === types.comma) {
+          this.raise(this.start, "Comma is not permitted after the rest element");
+        }
+        return this.finishNode(prop, "RestElement")
+      }
+      // To disallow parenthesized identifier via `this.toAssignable()`.
+      if (this.type === types.parenL && refDestructuringErrors) {
+        if (refDestructuringErrors.parenthesizedAssign < 0) {
+          refDestructuringErrors.parenthesizedAssign = this.start;
+        }
+        if (refDestructuringErrors.parenthesizedBind < 0) {
+          refDestructuringErrors.parenthesizedBind = this.start;
+        }
+      }
+      // Parse argument.
+      prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+      // To disallow trailing comma via `this.toAssignable()`.
+      if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
+        refDestructuringErrors.trailingComma = this.start;
+      }
+      // Finish
+      return this.finishNode(prop, "SpreadElement")
+    }
+    if (this.options.ecmaVersion >= 6) {
+      prop.method = false;
+      prop.shorthand = false;
+      if (isPattern || refDestructuringErrors) {
+        startPos = this.start;
+        startLoc = this.startLoc;
+      }
+      if (!isPattern)
+        { isGenerator = this.eat(types.star); }
+    }
+    var containsEsc = this.containsEsc;
+    this.parsePropertyName(prop);
+    if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
+      isAsync = true;
+      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+      this.parsePropertyName(prop, refDestructuringErrors);
+    } else {
+      isAsync = false;
+    }
+    this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
+    return this.finishNode(prop, "Property")
+  };
+
+  pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
+    if ((isGenerator || isAsync) && this.type === types.colon)
+      { this.unexpected(); }
+
+    if (this.eat(types.colon)) {
+      prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
+      prop.kind = "init";
+    } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
+      if (isPattern) { this.unexpected(); }
+      prop.kind = "init";
+      prop.method = true;
+      prop.value = this.parseMethod(isGenerator, isAsync);
+    } else if (!isPattern && !containsEsc &&
+               this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+               (prop.key.name === "get" || prop.key.name === "set") &&
+               (this.type !== types.comma && this.type !== types.braceR)) {
+      if (isGenerator || isAsync) { this.unexpected(); }
+      prop.kind = prop.key.name;
+      this.parsePropertyName(prop);
+      prop.value = this.parseMethod(false);
+      var paramCount = prop.kind === "get" ? 0 : 1;
+      if (prop.value.params.length !== paramCount) {
+        var start = prop.value.start;
+        if (prop.kind === "get")
+          { this.raiseRecoverable(start, "getter should have no params"); }
+        else
+          { this.raiseRecoverable(start, "setter should have exactly one param"); }
+      } else {
+        if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
+          { this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); }
+      }
+    } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+      if (isGenerator || isAsync) { this.unexpected(); }
+      this.checkUnreserved(prop.key);
+      if (prop.key.name === "await" && !this.awaitIdentPos)
+        { this.awaitIdentPos = startPos; }
+      prop.kind = "init";
+      if (isPattern) {
+        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+      } else if (this.type === types.eq && refDestructuringErrors) {
+        if (refDestructuringErrors.shorthandAssign < 0)
+          { refDestructuringErrors.shorthandAssign = this.start; }
+        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+      } else {
+        prop.value = prop.key;
+      }
+      prop.shorthand = true;
+    } else { this.unexpected(); }
+  };
+
+  pp$3.parsePropertyName = function(prop) {
+    if (this.options.ecmaVersion >= 6) {
+      if (this.eat(types.bracketL)) {
+        prop.computed = true;
+        prop.key = this.parseMaybeAssign();
+        this.expect(types.bracketR);
+        return prop.key
+      } else {
+        prop.computed = false;
+      }
+    }
+    return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never")
+  };
+
+  // Initialize empty function node.
+
+  pp$3.initFunction = function(node) {
+    node.id = null;
+    if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; }
+    if (this.options.ecmaVersion >= 8) { node.async = false; }
+  };
+
+  // Parse object or class method.
+
+  pp$3.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
+    var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+
+    this.initFunction(node);
+    if (this.options.ecmaVersion >= 6)
+      { node.generator = isGenerator; }
+    if (this.options.ecmaVersion >= 8)
+      { node.async = !!isAsync; }
+
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    this.awaitIdentPos = 0;
+    this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
+
+    this.expect(types.parenL);
+    node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+    this.checkYieldAwaitInDefaultParams();
+    this.parseFunctionBody(node, false, true);
+
+    this.yieldPos = oldYieldPos;
+    this.awaitPos = oldAwaitPos;
+    this.awaitIdentPos = oldAwaitIdentPos;
+    return this.finishNode(node, "FunctionExpression")
+  };
+
+  // Parse arrow function expression with given parameters.
+
+  pp$3.parseArrowExpression = function(node, params, isAsync) {
+    var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+
+    this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);
+    this.initFunction(node);
+    if (this.options.ecmaVersion >= 8) { node.async = !!isAsync; }
+
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    this.awaitIdentPos = 0;
+
+    node.params = this.toAssignableList(params, true);
+    this.parseFunctionBody(node, true, false);
+
+    this.yieldPos = oldYieldPos;
+    this.awaitPos = oldAwaitPos;
+    this.awaitIdentPos = oldAwaitIdentPos;
+    return this.finishNode(node, "ArrowFunctionExpression")
+  };
+
+  // Parse function body and check parameters.
+
+  pp$3.parseFunctionBody = function(node, isArrowFunction, isMethod) {
+    var isExpression = isArrowFunction && this.type !== types.braceL;
+    var oldStrict = this.strict, useStrict = false;
+
+    if (isExpression) {
+      node.body = this.parseMaybeAssign();
+      node.expression = true;
+      this.checkParams(node, false);
+    } else {
+      var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
+      if (!oldStrict || nonSimple) {
+        useStrict = this.strictDirective(this.end);
+        // If this is a strict mode function, verify that argument names
+        // are not repeated, and it does not try to bind the words `eval`
+        // or `arguments`.
+        if (useStrict && nonSimple)
+          { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
+      }
+      // Start a new scope with regard to labels and the `inFunction`
+      // flag (restore them to their old value afterwards).
+      var oldLabels = this.labels;
+      this.labels = [];
+      if (useStrict) { this.strict = true; }
+
+      // Add the params to varDeclaredNames to ensure that an error is thrown
+      // if a let/const declaration in the function clashes with one of the params.
+      this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));
+      node.body = this.parseBlock(false);
+      node.expression = false;
+      this.adaptDirectivePrologue(node.body.body);
+      this.labels = oldLabels;
+    }
+    this.exitScope();
+
+    // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
+    if (this.strict && node.id) { this.checkLVal(node.id, BIND_OUTSIDE); }
+    this.strict = oldStrict;
+  };
+
+  pp$3.isSimpleParamList = function(params) {
+    for (var i = 0, list = params; i < list.length; i += 1)
+      {
+      var param = list[i];
+
+      if (param.type !== "Identifier") { return false
+    } }
+    return true
+  };
+
+  // Checks function params for various disallowed patterns such as using "eval"
+  // or "arguments" and duplicate parameters.
+
+  pp$3.checkParams = function(node, allowDuplicates) {
+    var nameHash = {};
+    for (var i = 0, list = node.params; i < list.length; i += 1)
+      {
+      var param = list[i];
+
+      this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash);
+    }
+  };
+
+  // Parses a comma-separated list of expressions, and returns them as
+  // an array. `close` is the token type that ends the list, and
+  // `allowEmpty` can be turned on to allow subsequent commas with
+  // nothing in between them to be parsed as `null` (which is needed
+  // for array literals).
+
+  pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+    var elts = [], first = true;
+    while (!this.eat(close)) {
+      if (!first) {
+        this.expect(types.comma);
+        if (allowTrailingComma && this.afterTrailingComma(close)) { break }
+      } else { first = false; }
+
+      var elt = (void 0);
+      if (allowEmpty && this.type === types.comma)
+        { elt = null; }
+      else if (this.type === types.ellipsis) {
+        elt = this.parseSpread(refDestructuringErrors);
+        if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)
+          { refDestructuringErrors.trailingComma = this.start; }
+      } else {
+        elt = this.parseMaybeAssign(false, refDestructuringErrors);
+      }
+      elts.push(elt);
+    }
+    return elts
+  };
+
+  pp$3.checkUnreserved = function(ref) {
+    var start = ref.start;
+    var end = ref.end;
+    var name = ref.name;
+
+    if (this.inGenerator && name === "yield")
+      { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); }
+    if (this.inAsync && name === "await")
+      { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); }
+    if (this.keywords.test(name))
+      { this.raise(start, ("Unexpected keyword '" + name + "'")); }
+    if (this.options.ecmaVersion < 6 &&
+      this.input.slice(start, end).indexOf("\\") !== -1) { return }
+    var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
+    if (re.test(name)) {
+      if (!this.inAsync && name === "await")
+        { this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function"); }
+      this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved"));
+    }
+  };
+
+  // Parse the next token as an identifier. If `liberal` is true (used
+  // when parsing properties), it will also convert keywords into
+  // identifiers.
+
+  pp$3.parseIdent = function(liberal, isBinding) {
+    var node = this.startNode();
+    if (this.type === types.name) {
+      node.name = this.value;
+    } else if (this.type.keyword) {
+      node.name = this.type.keyword;
+
+      // To fix https://github.com/acornjs/acorn/issues/575
+      // `class` and `function` keywords push new context into this.context.
+      // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.
+      // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword
+      if ((node.name === "class" || node.name === "function") &&
+          (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
+        this.context.pop();
+      }
+    } else {
+      this.unexpected();
+    }
+    this.next();
+    this.finishNode(node, "Identifier");
+    if (!liberal) {
+      this.checkUnreserved(node);
+      if (node.name === "await" && !this.awaitIdentPos)
+        { this.awaitIdentPos = node.start; }
+    }
+    return node
+  };
+
+  // Parses yield expression inside generator.
+
+  pp$3.parseYield = function(noIn) {
+    if (!this.yieldPos) { this.yieldPos = this.start; }
+
+    var node = this.startNode();
+    this.next();
+    if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {
+      node.delegate = false;
+      node.argument = null;
+    } else {
+      node.delegate = this.eat(types.star);
+      node.argument = this.parseMaybeAssign(noIn);
+    }
+    return this.finishNode(node, "YieldExpression")
+  };
+
+  pp$3.parseAwait = function() {
+    if (!this.awaitPos) { this.awaitPos = this.start; }
+
+    var node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeUnary(null, true);
+    return this.finishNode(node, "AwaitExpression")
+  };
+
+  var pp$4 = Parser.prototype;
+
+  // This function is used to raise exceptions on parse errors. It
+  // takes an offset integer (into the current `input`) to indicate
+  // the location of the error, attaches the position to the end
+  // of the error message, and then raises a `SyntaxError` with that
+  // message.
+
+  pp$4.raise = function(pos, message) {
+    var loc = getLineInfo(this.input, pos);
+    message += " (" + loc.line + ":" + loc.column + ")";
+    var err = new SyntaxError(message);
+    err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+    throw err
+  };
+
+  pp$4.raiseRecoverable = pp$4.raise;
+
+  pp$4.curPosition = function() {
+    if (this.options.locations) {
+      return new Position(this.curLine, this.pos - this.lineStart)
+    }
+  };
+
+  var pp$5 = Parser.prototype;
+
+  var Scope = function Scope(flags) {
+    this.flags = flags;
+    // A list of var-declared names in the current lexical scope
+    this.var = [];
+    // A list of lexically-declared names in the current lexical scope
+    this.lexical = [];
+    // A list of lexically-declared FunctionDeclaration names in the current lexical scope
+    this.functions = [];
+  };
+
+  // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
+
+  pp$5.enterScope = function(flags) {
+    this.scopeStack.push(new Scope(flags));
+  };
+
+  pp$5.exitScope = function() {
+    this.scopeStack.pop();
+  };
+
+  // The spec says:
+  // > At the top level of a function, or script, function declarations are
+  // > treated like var declarations rather than like lexical declarations.
+  pp$5.treatFunctionsAsVarInScope = function(scope) {
+    return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)
+  };
+
+  pp$5.declareName = function(name, bindingType, pos) {
+    var redeclared = false;
+    if (bindingType === BIND_LEXICAL) {
+      var scope = this.currentScope();
+      redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
+      scope.lexical.push(name);
+      if (this.inModule && (scope.flags & SCOPE_TOP))
+        { delete this.undefinedExports[name]; }
+    } else if (bindingType === BIND_SIMPLE_CATCH) {
+      var scope$1 = this.currentScope();
+      scope$1.lexical.push(name);
+    } else if (bindingType === BIND_FUNCTION) {
+      var scope$2 = this.currentScope();
+      if (this.treatFunctionsAsVar)
+        { redeclared = scope$2.lexical.indexOf(name) > -1; }
+      else
+        { redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; }
+      scope$2.functions.push(name);
+    } else {
+      for (var i = this.scopeStack.length - 1; i >= 0; --i) {
+        var scope$3 = this.scopeStack[i];
+        if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) ||
+            !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {
+          redeclared = true;
+          break
+        }
+        scope$3.var.push(name);
+        if (this.inModule && (scope$3.flags & SCOPE_TOP))
+          { delete this.undefinedExports[name]; }
+        if (scope$3.flags & SCOPE_VAR) { break }
+      }
+    }
+    if (redeclared) { this.raiseRecoverable(pos, ("Identifier '" + name + "' has already been declared")); }
+  };
+
+  pp$5.checkLocalExport = function(id) {
+    // scope.functions must be empty as Module code is always strict.
+    if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&
+        this.scopeStack[0].var.indexOf(id.name) === -1) {
+      this.undefinedExports[id.name] = id;
+    }
+  };
+
+  pp$5.currentScope = function() {
+    return this.scopeStack[this.scopeStack.length - 1]
+  };
+
+  pp$5.currentVarScope = function() {
+    for (var i = this.scopeStack.length - 1;; i--) {
+      var scope = this.scopeStack[i];
+      if (scope.flags & SCOPE_VAR) { return scope }
+    }
+  };
+
+  // Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.
+  pp$5.currentThisScope = function() {
+    for (var i = this.scopeStack.length - 1;; i--) {
+      var scope = this.scopeStack[i];
+      if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }
+    }
+  };
+
+  var Node = function Node(parser, pos, loc) {
+    this.type = "";
+    this.start = pos;
+    this.end = 0;
+    if (parser.options.locations)
+      { this.loc = new SourceLocation(parser, loc); }
+    if (parser.options.directSourceFile)
+      { this.sourceFile = parser.options.directSourceFile; }
+    if (parser.options.ranges)
+      { this.range = [pos, 0]; }
+  };
+
+  // Start an AST node, attaching a start offset.
+
+  var pp$6 = Parser.prototype;
+
+  pp$6.startNode = function() {
+    return new Node(this, this.start, this.startLoc)
+  };
+
+  pp$6.startNodeAt = function(pos, loc) {
+    return new Node(this, pos, loc)
+  };
+
+  // Finish an AST node, adding `type` and `end` properties.
+
+  function finishNodeAt(node, type, pos, loc) {
+    node.type = type;
+    node.end = pos;
+    if (this.options.locations)
+      { node.loc.end = loc; }
+    if (this.options.ranges)
+      { node.range[1] = pos; }
+    return node
+  }
+
+  pp$6.finishNode = function(node, type) {
+    return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
+  };
+
+  // Finish node at given position
+
+  pp$6.finishNodeAt = function(node, type, pos, loc) {
+    return finishNodeAt.call(this, node, type, pos, loc)
+  };
+
+  // The algorithm used to determine whether a regexp can appear at a
+
+  var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
+    this.token = token;
+    this.isExpr = !!isExpr;
+    this.preserveSpace = !!preserveSpace;
+    this.override = override;
+    this.generator = !!generator;
+  };
+
+  var types$1 = {
+    b_stat: new TokContext("{", false),
+    b_expr: new TokContext("{", true),
+    b_tmpl: new TokContext("${", false),
+    p_stat: new TokContext("(", false),
+    p_expr: new TokContext("(", true),
+    q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }),
+    f_stat: new TokContext("function", false),
+    f_expr: new TokContext("function", true),
+    f_expr_gen: new TokContext("function", true, false, null, true),
+    f_gen: new TokContext("function", false, false, null, true)
+  };
+
+  var pp$7 = Parser.prototype;
+
+  pp$7.initialContext = function() {
+    return [types$1.b_stat]
+  };
+
+  pp$7.braceIsBlock = function(prevType) {
+    var parent = this.curContext();
+    if (parent === types$1.f_expr || parent === types$1.f_stat)
+      { return true }
+    if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
+      { return !parent.isExpr }
+
+    // The check for `tt.name && exprAllowed` detects whether we are
+    // after a `yield` or `of` construct. See the `updateContext` for
+    // `tt.name`.
+    if (prevType === types._return || prevType === types.name && this.exprAllowed)
+      { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
+    if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)
+      { return true }
+    if (prevType === types.braceL)
+      { return parent === types$1.b_stat }
+    if (prevType === types._var || prevType === types._const || prevType === types.name)
+      { return false }
+    return !this.exprAllowed
+  };
+
+  pp$7.inGeneratorContext = function() {
+    for (var i = this.context.length - 1; i >= 1; i--) {
+      var context = this.context[i];
+      if (context.token === "function")
+        { return context.generator }
+    }
+    return false
+  };
+
+  pp$7.updateContext = function(prevType) {
+    var update, type = this.type;
+    if (type.keyword && prevType === types.dot)
+      { this.exprAllowed = false; }
+    else if (update = type.updateContext)
+      { update.call(this, prevType); }
+    else
+      { this.exprAllowed = type.beforeExpr; }
+  };
+
+  // Token-specific context update code
+
+  types.parenR.updateContext = types.braceR.updateContext = function() {
+    if (this.context.length === 1) {
+      this.exprAllowed = true;
+      return
+    }
+    var out = this.context.pop();
+    if (out === types$1.b_stat && this.curContext().token === "function") {
+      out = this.context.pop();
+    }
+    this.exprAllowed = !out.isExpr;
+  };
+
+  types.braceL.updateContext = function(prevType) {
+    this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
+    this.exprAllowed = true;
+  };
+
+  types.dollarBraceL.updateContext = function() {
+    this.context.push(types$1.b_tmpl);
+    this.exprAllowed = true;
+  };
+
+  types.parenL.updateContext = function(prevType) {
+    var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
+    this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
+    this.exprAllowed = true;
+  };
+
+  types.incDec.updateContext = function() {
+    // tokExprAllowed stays unchanged
+  };
+
+  types._function.updateContext = types._class.updateContext = function(prevType) {
+    if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
+        !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&
+        !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
+      { this.context.push(types$1.f_expr); }
+    else
+      { this.context.push(types$1.f_stat); }
+    this.exprAllowed = false;
+  };
+
+  types.backQuote.updateContext = function() {
+    if (this.curContext() === types$1.q_tmpl)
+      { this.context.pop(); }
+    else
+      { this.context.push(types$1.q_tmpl); }
+    this.exprAllowed = false;
+  };
+
+  types.star.updateContext = function(prevType) {
+    if (prevType === types._function) {
+      var index = this.context.length - 1;
+      if (this.context[index] === types$1.f_expr)
+        { this.context[index] = types$1.f_expr_gen; }
+      else
+        { this.context[index] = types$1.f_gen; }
+    }
+    this.exprAllowed = true;
+  };
+
+  types.name.updateContext = function(prevType) {
+    var allowed = false;
+    if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {
+      if (this.value === "of" && !this.exprAllowed ||
+          this.value === "yield" && this.inGeneratorContext())
+        { allowed = true; }
+    }
+    this.exprAllowed = allowed;
+  };
+
+  // This file contains Unicode properties extracted from the ECMAScript
+  // specification. The lists are extracted like so:
+  // $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)
+
+  // #table-binary-unicode-properties
+  var ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
+  var ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic";
+  var ecma11BinaryProperties = ecma10BinaryProperties;
+  var unicodeBinaryProperties = {
+    9: ecma9BinaryProperties,
+    10: ecma10BinaryProperties,
+    11: ecma11BinaryProperties
+  };
+
+  // #table-unicode-general-category-values
+  var unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu";
+
+  // #table-unicode-script-values
+  var ecma9ScriptValues = "Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
+  var ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
+  var ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
+  var unicodeScriptValues = {
+    9: ecma9ScriptValues,
+    10: ecma10ScriptValues,
+    11: ecma11ScriptValues
+  };
+
+  var data = {};
+  function buildUnicodeData(ecmaVersion) {
+    var d = data[ecmaVersion] = {
+      binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues),
+      nonBinary: {
+        General_Category: wordsRegexp(unicodeGeneralCategoryValues),
+        Script: wordsRegexp(unicodeScriptValues[ecmaVersion])
+      }
+    };
+    d.nonBinary.Script_Extensions = d.nonBinary.Script;
+
+    d.nonBinary.gc = d.nonBinary.General_Category;
+    d.nonBinary.sc = d.nonBinary.Script;
+    d.nonBinary.scx = d.nonBinary.Script_Extensions;
+  }
+  buildUnicodeData(9);
+  buildUnicodeData(10);
+  buildUnicodeData(11);
+
+  var pp$8 = Parser.prototype;
+
+  var RegExpValidationState = function RegExpValidationState(parser) {
+    this.parser = parser;
+    this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
+    this.unicodeProperties = data[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];
+    this.source = "";
+    this.flags = "";
+    this.start = 0;
+    this.switchU = false;
+    this.switchN = false;
+    this.pos = 0;
+    this.lastIntValue = 0;
+    this.lastStringValue = "";
+    this.lastAssertionIsQuantifiable = false;
+    this.numCapturingParens = 0;
+    this.maxBackReference = 0;
+    this.groupNames = [];
+    this.backReferenceNames = [];
+  };
+
+  RegExpValidationState.prototype.reset = function reset (start, pattern, flags) {
+    var unicode = flags.indexOf("u") !== -1;
+    this.start = start | 0;
+    this.source = pattern + "";
+    this.flags = flags;
+    this.switchU = unicode && this.parser.options.ecmaVersion >= 6;
+    this.switchN = unicode && this.parser.options.ecmaVersion >= 9;
+  };
+
+  RegExpValidationState.prototype.raise = function raise (message) {
+    this.parser.raiseRecoverable(this.start, ("Invalid regular expression: /" + (this.source) + "/: " + message));
+  };
+
+  // If u flag is given, this returns the code point at the index (it combines a surrogate pair).
+  // Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).
+  RegExpValidationState.prototype.at = function at (i) {
+    var s = this.source;
+    var l = s.length;
+    if (i >= l) {
+      return -1
+    }
+    var c = s.charCodeAt(i);
+    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
+      return c
+    }
+    var next = s.charCodeAt(i + 1);
+    return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c
+  };
+
+  RegExpValidationState.prototype.nextIndex = function nextIndex (i) {
+    var s = this.source;
+    var l = s.length;
+    if (i >= l) {
+      return l
+    }
+    var c = s.charCodeAt(i), next;
+    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||
+        (next = s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) {
+      return i + 1
+    }
+    return i + 2
+  };
+
+  RegExpValidationState.prototype.current = function current () {
+    return this.at(this.pos)
+  };
+
+  RegExpValidationState.prototype.lookahead = function lookahead () {
+    return this.at(this.nextIndex(this.pos))
+  };
+
+  RegExpValidationState.prototype.advance = function advance () {
+    this.pos = this.nextIndex(this.pos);
+  };
+
+  RegExpValidationState.prototype.eat = function eat (ch) {
+    if (this.current() === ch) {
+      this.advance();
+      return true
+    }
+    return false
+  };
+
+  function codePointToString(ch) {
+    if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
+    ch -= 0x10000;
+    return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)
+  }
+
+  /**
+   * Validate the flags part of a given RegExpLiteral.
+   *
+   * @param {RegExpValidationState} state The state to validate RegExp.
+   * @returns {void}
+   */
+  pp$8.validateRegExpFlags = function(state) {
+    var validFlags = state.validFlags;
+    var flags = state.flags;
+
+    for (var i = 0; i < flags.length; i++) {
+      var flag = flags.charAt(i);
+      if (validFlags.indexOf(flag) === -1) {
+        this.raise(state.start, "Invalid regular expression flag");
+      }
+      if (flags.indexOf(flag, i + 1) > -1) {
+        this.raise(state.start, "Duplicate regular expression flag");
+      }
+    }
+  };
+
+  /**
+   * Validate the pattern part of a given RegExpLiteral.
+   *
+   * @param {RegExpValidationState} state The state to validate RegExp.
+   * @returns {void}
+   */
+  pp$8.validateRegExpPattern = function(state) {
+    this.regexp_pattern(state);
+
+    // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of
+    // parsing contains a |GroupName|, reparse with the goal symbol
+    // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*
+    // exception if _P_ did not conform to the grammar, if any elements of _P_
+    // were not matched by the parse, or if any Early Error conditions exist.
+    if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
+      state.switchN = true;
+      this.regexp_pattern(state);
+    }
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern
+  pp$8.regexp_pattern = function(state) {
+    state.pos = 0;
+    state.lastIntValue = 0;
+    state.lastStringValue = "";
+    state.lastAssertionIsQuantifiable = false;
+    state.numCapturingParens = 0;
+    state.maxBackReference = 0;
+    state.groupNames.length = 0;
+    state.backReferenceNames.length = 0;
+
+    this.regexp_disjunction(state);
+
+    if (state.pos !== state.source.length) {
+      // Make the same messages as V8.
+      if (state.eat(0x29 /* ) */)) {
+        state.raise("Unmatched ')'");
+      }
+      if (state.eat(0x5D /* [ */) || state.eat(0x7D /* } */)) {
+        state.raise("Lone quantifier brackets");
+      }
+    }
+    if (state.maxBackReference > state.numCapturingParens) {
+      state.raise("Invalid escape");
+    }
+    for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
+      var name = list[i];
+
+      if (state.groupNames.indexOf(name) === -1) {
+        state.raise("Invalid named capture referenced");
+      }
+    }
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction
+  pp$8.regexp_disjunction = function(state) {
+    this.regexp_alternative(state);
+    while (state.eat(0x7C /* | */)) {
+      this.regexp_alternative(state);
+    }
+
+    // Make the same message as V8.
+    if (this.regexp_eatQuantifier(state, true)) {
+      state.raise("Nothing to repeat");
+    }
+    if (state.eat(0x7B /* { */)) {
+      state.raise("Lone quantifier brackets");
+    }
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative
+  pp$8.regexp_alternative = function(state) {
+    while (state.pos < state.source.length && this.regexp_eatTerm(state))
+      { }
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term
+  pp$8.regexp_eatTerm = function(state) {
+    if (this.regexp_eatAssertion(state)) {
+      // Handle `QuantifiableAssertion Quantifier` alternative.
+      // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion
+      // is a QuantifiableAssertion.
+      if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
+        // Make the same message as V8.
+        if (state.switchU) {
+          state.raise("Invalid quantifier");
+        }
+      }
+      return true
+    }
+
+    if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
+      this.regexp_eatQuantifier(state);
+      return true
+    }
+
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion
+  pp$8.regexp_eatAssertion = function(state) {
+    var start = state.pos;
+    state.lastAssertionIsQuantifiable = false;
+
+    // ^, $
+    if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {
+      return true
+    }
+
+    // \b \B
+    if (state.eat(0x5C /* \ */)) {
+      if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {
+        return true
+      }
+      state.pos = start;
+    }
+
+    // Lookahead / Lookbehind
+    if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {
+      var lookbehind = false;
+      if (this.options.ecmaVersion >= 9) {
+        lookbehind = state.eat(0x3C /* < */);
+      }
+      if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {
+        this.regexp_disjunction(state);
+        if (!state.eat(0x29 /* ) */)) {
+          state.raise("Unterminated group");
+        }
+        state.lastAssertionIsQuantifiable = !lookbehind;
+        return true
+      }
+    }
+
+    state.pos = start;
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier
+  pp$8.regexp_eatQuantifier = function(state, noError) {
+    if ( noError === void 0 ) noError = false;
+
+    if (this.regexp_eatQuantifierPrefix(state, noError)) {
+      state.eat(0x3F /* ? */);
+      return true
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix
+  pp$8.regexp_eatQuantifierPrefix = function(state, noError) {
+    return (
+      state.eat(0x2A /* * */) ||
+      state.eat(0x2B /* + */) ||
+      state.eat(0x3F /* ? */) ||
+      this.regexp_eatBracedQuantifier(state, noError)
+    )
+  };
+  pp$8.regexp_eatBracedQuantifier = function(state, noError) {
+    var start = state.pos;
+    if (state.eat(0x7B /* { */)) {
+      var min = 0, max = -1;
+      if (this.regexp_eatDecimalDigits(state)) {
+        min = state.lastIntValue;
+        if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {
+          max = state.lastIntValue;
+        }
+        if (state.eat(0x7D /* } */)) {
+          // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term
+          if (max !== -1 && max < min && !noError) {
+            state.raise("numbers out of order in {} quantifier");
+          }
+          return true
+        }
+      }
+      if (state.switchU && !noError) {
+        state.raise("Incomplete quantifier");
+      }
+      state.pos = start;
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-Atom
+  pp$8.regexp_eatAtom = function(state) {
+    return (
+      this.regexp_eatPatternCharacters(state) ||
+      state.eat(0x2E /* . */) ||
+      this.regexp_eatReverseSolidusAtomEscape(state) ||
+      this.regexp_eatCharacterClass(state) ||
+      this.regexp_eatUncapturingGroup(state) ||
+      this.regexp_eatCapturingGroup(state)
+    )
+  };
+  pp$8.regexp_eatReverseSolidusAtomEscape = function(state) {
+    var start = state.pos;
+    if (state.eat(0x5C /* \ */)) {
+      if (this.regexp_eatAtomEscape(state)) {
+        return true
+      }
+      state.pos = start;
+    }
+    return false
+  };
+  pp$8.regexp_eatUncapturingGroup = function(state) {
+    var start = state.pos;
+    if (state.eat(0x28 /* ( */)) {
+      if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {
+        this.regexp_disjunction(state);
+        if (state.eat(0x29 /* ) */)) {
+          return true
+        }
+        state.raise("Unterminated group");
+      }
+      state.pos = start;
+    }
+    return false
+  };
+  pp$8.regexp_eatCapturingGroup = function(state) {
+    if (state.eat(0x28 /* ( */)) {
+      if (this.options.ecmaVersion >= 9) {
+        this.regexp_groupSpecifier(state);
+      } else if (state.current() === 0x3F /* ? */) {
+        state.raise("Invalid group");
+      }
+      this.regexp_disjunction(state);
+      if (state.eat(0x29 /* ) */)) {
+        state.numCapturingParens += 1;
+        return true
+      }
+      state.raise("Unterminated group");
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom
+  pp$8.regexp_eatExtendedAtom = function(state) {
+    return (
+      state.eat(0x2E /* . */) ||
+      this.regexp_eatReverseSolidusAtomEscape(state) ||
+      this.regexp_eatCharacterClass(state) ||
+      this.regexp_eatUncapturingGroup(state) ||
+      this.regexp_eatCapturingGroup(state) ||
+      this.regexp_eatInvalidBracedQuantifier(state) ||
+      this.regexp_eatExtendedPatternCharacter(state)
+    )
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier
+  pp$8.regexp_eatInvalidBracedQuantifier = function(state) {
+    if (this.regexp_eatBracedQuantifier(state, true)) {
+      state.raise("Nothing to repeat");
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter
+  pp$8.regexp_eatSyntaxCharacter = function(state) {
+    var ch = state.current();
+    if (isSyntaxCharacter(ch)) {
+      state.lastIntValue = ch;
+      state.advance();
+      return true
+    }
+    return false
+  };
+  function isSyntaxCharacter(ch) {
+    return (
+      ch === 0x24 /* $ */ ||
+      ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||
+      ch === 0x2E /* . */ ||
+      ch === 0x3F /* ? */ ||
+      ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||
+      ch >= 0x7B /* { */ && ch <= 0x7D /* } */
+    )
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter
+  // But eat eager.
+  pp$8.regexp_eatPatternCharacters = function(state) {
+    var start = state.pos;
+    var ch = 0;
+    while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
+      state.advance();
+    }
+    return state.pos !== start
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter
+  pp$8.regexp_eatExtendedPatternCharacter = function(state) {
+    var ch = state.current();
+    if (
+      ch !== -1 &&
+      ch !== 0x24 /* $ */ &&
+      !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&
+      ch !== 0x2E /* . */ &&
+      ch !== 0x3F /* ? */ &&
+      ch !== 0x5B /* [ */ &&
+      ch !== 0x5E /* ^ */ &&
+      ch !== 0x7C /* | */
+    ) {
+      state.advance();
+      return true
+    }
+    return false
+  };
+
+  // GroupSpecifier[U] ::
+  //   [empty]
+  //   `?` GroupName[?U]
+  pp$8.regexp_groupSpecifier = function(state) {
+    if (state.eat(0x3F /* ? */)) {
+      if (this.regexp_eatGroupName(state)) {
+        if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
+          state.raise("Duplicate capture group name");
+        }
+        state.groupNames.push(state.lastStringValue);
+        return
+      }
+      state.raise("Invalid group");
+    }
+  };
+
+  // GroupName[U] ::
+  //   `<` RegExpIdentifierName[?U] `>`
+  // Note: this updates `state.lastStringValue` property with the eaten name.
+  pp$8.regexp_eatGroupName = function(state) {
+    state.lastStringValue = "";
+    if (state.eat(0x3C /* < */)) {
+      if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {
+        return true
+      }
+      state.raise("Invalid capture group name");
+    }
+    return false
+  };
+
+  // RegExpIdentifierName[U] ::
+  //   RegExpIdentifierStart[?U]
+  //   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]
+  // Note: this updates `state.lastStringValue` property with the eaten name.
+  pp$8.regexp_eatRegExpIdentifierName = function(state) {
+    state.lastStringValue = "";
+    if (this.regexp_eatRegExpIdentifierStart(state)) {
+      state.lastStringValue += codePointToString(state.lastIntValue);
+      while (this.regexp_eatRegExpIdentifierPart(state)) {
+        state.lastStringValue += codePointToString(state.lastIntValue);
+      }
+      return true
+    }
+    return false
+  };
+
+  // RegExpIdentifierStart[U] ::
+  //   UnicodeIDStart
+  //   `$`
+  //   `_`
+  //   `\` RegExpUnicodeEscapeSequence[?U]
+  pp$8.regexp_eatRegExpIdentifierStart = function(state) {
+    var start = state.pos;
+    var ch = state.current();
+    state.advance();
+
+    if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+      ch = state.lastIntValue;
+    }
+    if (isRegExpIdentifierStart(ch)) {
+      state.lastIntValue = ch;
+      return true
+    }
+
+    state.pos = start;
+    return false
+  };
+  function isRegExpIdentifierStart(ch) {
+    return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */
+  }
+
+  // RegExpIdentifierPart[U] ::
+  //   UnicodeIDContinue
+  //   `$`
+  //   `_`
+  //   `\` RegExpUnicodeEscapeSequence[?U]
+  //   <ZWNJ>
+  //   <ZWJ>
+  pp$8.regexp_eatRegExpIdentifierPart = function(state) {
+    var start = state.pos;
+    var ch = state.current();
+    state.advance();
+
+    if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+      ch = state.lastIntValue;
+    }
+    if (isRegExpIdentifierPart(ch)) {
+      state.lastIntValue = ch;
+      return true
+    }
+
+    state.pos = start;
+    return false
+  };
+  function isRegExpIdentifierPart(ch) {
+    return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape
+  pp$8.regexp_eatAtomEscape = function(state) {
+    if (
+      this.regexp_eatBackReference(state) ||
+      this.regexp_eatCharacterClassEscape(state) ||
+      this.regexp_eatCharacterEscape(state) ||
+      (state.switchN && this.regexp_eatKGroupName(state))
+    ) {
+      return true
+    }
+    if (state.switchU) {
+      // Make the same message as V8.
+      if (state.current() === 0x63 /* c */) {
+        state.raise("Invalid unicode escape");
+      }
+      state.raise("Invalid escape");
+    }
+    return false
+  };
+  pp$8.regexp_eatBackReference = function(state) {
+    var start = state.pos;
+    if (this.regexp_eatDecimalEscape(state)) {
+      var n = state.lastIntValue;
+      if (state.switchU) {
+        // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape
+        if (n > state.maxBackReference) {
+          state.maxBackReference = n;
+        }
+        return true
+      }
+      if (n <= state.numCapturingParens) {
+        return true
+      }
+      state.pos = start;
+    }
+    return false
+  };
+  pp$8.regexp_eatKGroupName = function(state) {
+    if (state.eat(0x6B /* k */)) {
+      if (this.regexp_eatGroupName(state)) {
+        state.backReferenceNames.push(state.lastStringValue);
+        return true
+      }
+      state.raise("Invalid named reference");
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape
+  pp$8.regexp_eatCharacterEscape = function(state) {
+    return (
+      this.regexp_eatControlEscape(state) ||
+      this.regexp_eatCControlLetter(state) ||
+      this.regexp_eatZero(state) ||
+      this.regexp_eatHexEscapeSequence(state) ||
+      this.regexp_eatRegExpUnicodeEscapeSequence(state) ||
+      (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
+      this.regexp_eatIdentityEscape(state)
+    )
+  };
+  pp$8.regexp_eatCControlLetter = function(state) {
+    var start = state.pos;
+    if (state.eat(0x63 /* c */)) {
+      if (this.regexp_eatControlLetter(state)) {
+        return true
+      }
+      state.pos = start;
+    }
+    return false
+  };
+  pp$8.regexp_eatZero = function(state) {
+    if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {
+      state.lastIntValue = 0;
+      state.advance();
+      return true
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape
+  pp$8.regexp_eatControlEscape = function(state) {
+    var ch = state.current();
+    if (ch === 0x74 /* t */) {
+      state.lastIntValue = 0x09; /* \t */
+      state.advance();
+      return true
+    }
+    if (ch === 0x6E /* n */) {
+      state.lastIntValue = 0x0A; /* \n */
+      state.advance();
+      return true
+    }
+    if (ch === 0x76 /* v */) {
+      state.lastIntValue = 0x0B; /* \v */
+      state.advance();
+      return true
+    }
+    if (ch === 0x66 /* f */) {
+      state.lastIntValue = 0x0C; /* \f */
+      state.advance();
+      return true
+    }
+    if (ch === 0x72 /* r */) {
+      state.lastIntValue = 0x0D; /* \r */
+      state.advance();
+      return true
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter
+  pp$8.regexp_eatControlLetter = function(state) {
+    var ch = state.current();
+    if (isControlLetter(ch)) {
+      state.lastIntValue = ch % 0x20;
+      state.advance();
+      return true
+    }
+    return false
+  };
+  function isControlLetter(ch) {
+    return (
+      (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||
+      (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)
+    )
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence
+  pp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state) {
+    var start = state.pos;
+
+    if (state.eat(0x75 /* u */)) {
+      if (this.regexp_eatFixedHexDigits(state, 4)) {
+        var lead = state.lastIntValue;
+        if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {
+          var leadSurrogateEnd = state.pos;
+          if (state.eat(0x5C /* \ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {
+            var trail = state.lastIntValue;
+            if (trail >= 0xDC00 && trail <= 0xDFFF) {
+              state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+              return true
+            }
+          }
+          state.pos = leadSurrogateEnd;
+          state.lastIntValue = lead;
+        }
+        return true
+      }
+      if (
+        state.switchU &&
+        state.eat(0x7B /* { */) &&
+        this.regexp_eatHexDigits(state) &&
+        state.eat(0x7D /* } */) &&
+        isValidUnicode(state.lastIntValue)
+      ) {
+        return true
+      }
+      if (state.switchU) {
+        state.raise("Invalid unicode escape");
+      }
+      state.pos = start;
+    }
+
+    return false
+  };
+  function isValidUnicode(ch) {
+    return ch >= 0 && ch <= 0x10FFFF
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape
+  pp$8.regexp_eatIdentityEscape = function(state) {
+    if (state.switchU) {
+      if (this.regexp_eatSyntaxCharacter(state)) {
+        return true
+      }
+      if (state.eat(0x2F /* / */)) {
+        state.lastIntValue = 0x2F; /* / */
+        return true
+      }
+      return false
+    }
+
+    var ch = state.current();
+    if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {
+      state.lastIntValue = ch;
+      state.advance();
+      return true
+    }
+
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape
+  pp$8.regexp_eatDecimalEscape = function(state) {
+    state.lastIntValue = 0;
+    var ch = state.current();
+    if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {
+      do {
+        state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+        state.advance();
+      } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)
+      return true
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape
+  pp$8.regexp_eatCharacterClassEscape = function(state) {
+    var ch = state.current();
+
+    if (isCharacterClassEscape(ch)) {
+      state.lastIntValue = -1;
+      state.advance();
+      return true
+    }
+
+    if (
+      state.switchU &&
+      this.options.ecmaVersion >= 9 &&
+      (ch === 0x50 /* P */ || ch === 0x70 /* p */)
+    ) {
+      state.lastIntValue = -1;
+      state.advance();
+      if (
+        state.eat(0x7B /* { */) &&
+        this.regexp_eatUnicodePropertyValueExpression(state) &&
+        state.eat(0x7D /* } */)
+      ) {
+        return true
+      }
+      state.raise("Invalid property name");
+    }
+
+    return false
+  };
+  function isCharacterClassEscape(ch) {
+    return (
+      ch === 0x64 /* d */ ||
+      ch === 0x44 /* D */ ||
+      ch === 0x73 /* s */ ||
+      ch === 0x53 /* S */ ||
+      ch === 0x77 /* w */ ||
+      ch === 0x57 /* W */
+    )
+  }
+
+  // UnicodePropertyValueExpression ::
+  //   UnicodePropertyName `=` UnicodePropertyValue
+  //   LoneUnicodePropertyNameOrValue
+  pp$8.regexp_eatUnicodePropertyValueExpression = function(state) {
+    var start = state.pos;
+
+    // UnicodePropertyName `=` UnicodePropertyValue
+    if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {
+      var name = state.lastStringValue;
+      if (this.regexp_eatUnicodePropertyValue(state)) {
+        var value = state.lastStringValue;
+        this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
+        return true
+      }
+    }
+    state.pos = start;
+
+    // LoneUnicodePropertyNameOrValue
+    if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
+      var nameOrValue = state.lastStringValue;
+      this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
+      return true
+    }
+    return false
+  };
+  pp$8.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+    if (!has(state.unicodeProperties.nonBinary, name))
+      { state.raise("Invalid property name"); }
+    if (!state.unicodeProperties.nonBinary[name].test(value))
+      { state.raise("Invalid property value"); }
+  };
+  pp$8.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
+    if (!state.unicodeProperties.binary.test(nameOrValue))
+      { state.raise("Invalid property name"); }
+  };
+
+  // UnicodePropertyName ::
+  //   UnicodePropertyNameCharacters
+  pp$8.regexp_eatUnicodePropertyName = function(state) {
+    var ch = 0;
+    state.lastStringValue = "";
+    while (isUnicodePropertyNameCharacter(ch = state.current())) {
+      state.lastStringValue += codePointToString(ch);
+      state.advance();
+    }
+    return state.lastStringValue !== ""
+  };
+  function isUnicodePropertyNameCharacter(ch) {
+    return isControlLetter(ch) || ch === 0x5F /* _ */
+  }
+
+  // UnicodePropertyValue ::
+  //   UnicodePropertyValueCharacters
+  pp$8.regexp_eatUnicodePropertyValue = function(state) {
+    var ch = 0;
+    state.lastStringValue = "";
+    while (isUnicodePropertyValueCharacter(ch = state.current())) {
+      state.lastStringValue += codePointToString(ch);
+      state.advance();
+    }
+    return state.lastStringValue !== ""
+  };
+  function isUnicodePropertyValueCharacter(ch) {
+    return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)
+  }
+
+  // LoneUnicodePropertyNameOrValue ::
+  //   UnicodePropertyValueCharacters
+  pp$8.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
+    return this.regexp_eatUnicodePropertyValue(state)
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass
+  pp$8.regexp_eatCharacterClass = function(state) {
+    if (state.eat(0x5B /* [ */)) {
+      state.eat(0x5E /* ^ */);
+      this.regexp_classRanges(state);
+      if (state.eat(0x5D /* [ */)) {
+        return true
+      }
+      // Unreachable since it threw "unterminated regular expression" error before.
+      state.raise("Unterminated character class");
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash
+  pp$8.regexp_classRanges = function(state) {
+    while (this.regexp_eatClassAtom(state)) {
+      var left = state.lastIntValue;
+      if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {
+        var right = state.lastIntValue;
+        if (state.switchU && (left === -1 || right === -1)) {
+          state.raise("Invalid character class");
+        }
+        if (left !== -1 && right !== -1 && left > right) {
+          state.raise("Range out of order in character class");
+        }
+      }
+    }
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash
+  pp$8.regexp_eatClassAtom = function(state) {
+    var start = state.pos;
+
+    if (state.eat(0x5C /* \ */)) {
+      if (this.regexp_eatClassEscape(state)) {
+        return true
+      }
+      if (state.switchU) {
+        // Make the same message as V8.
+        var ch$1 = state.current();
+        if (ch$1 === 0x63 /* c */ || isOctalDigit(ch$1)) {
+          state.raise("Invalid class escape");
+        }
+        state.raise("Invalid escape");
+      }
+      state.pos = start;
+    }
+
+    var ch = state.current();
+    if (ch !== 0x5D /* [ */) {
+      state.lastIntValue = ch;
+      state.advance();
+      return true
+    }
+
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape
+  pp$8.regexp_eatClassEscape = function(state) {
+    var start = state.pos;
+
+    if (state.eat(0x62 /* b */)) {
+      state.lastIntValue = 0x08; /* <BS> */
+      return true
+    }
+
+    if (state.switchU && state.eat(0x2D /* - */)) {
+      state.lastIntValue = 0x2D; /* - */
+      return true
+    }
+
+    if (!state.switchU && state.eat(0x63 /* c */)) {
+      if (this.regexp_eatClassControlLetter(state)) {
+        return true
+      }
+      state.pos = start;
+    }
+
+    return (
+      this.regexp_eatCharacterClassEscape(state) ||
+      this.regexp_eatCharacterEscape(state)
+    )
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter
+  pp$8.regexp_eatClassControlLetter = function(state) {
+    var ch = state.current();
+    if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {
+      state.lastIntValue = ch % 0x20;
+      state.advance();
+      return true
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+  pp$8.regexp_eatHexEscapeSequence = function(state) {
+    var start = state.pos;
+    if (state.eat(0x78 /* x */)) {
+      if (this.regexp_eatFixedHexDigits(state, 2)) {
+        return true
+      }
+      if (state.switchU) {
+        state.raise("Invalid escape");
+      }
+      state.pos = start;
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits
+  pp$8.regexp_eatDecimalDigits = function(state) {
+    var start = state.pos;
+    var ch = 0;
+    state.lastIntValue = 0;
+    while (isDecimalDigit(ch = state.current())) {
+      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+      state.advance();
+    }
+    return state.pos !== start
+  };
+  function isDecimalDigit(ch) {
+    return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits
+  pp$8.regexp_eatHexDigits = function(state) {
+    var start = state.pos;
+    var ch = 0;
+    state.lastIntValue = 0;
+    while (isHexDigit(ch = state.current())) {
+      state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+      state.advance();
+    }
+    return state.pos !== start
+  };
+  function isHexDigit(ch) {
+    return (
+      (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||
+      (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||
+      (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)
+    )
+  }
+  function hexToInt(ch) {
+    if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {
+      return 10 + (ch - 0x41 /* A */)
+    }
+    if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {
+      return 10 + (ch - 0x61 /* a */)
+    }
+    return ch - 0x30 /* 0 */
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence
+  // Allows only 0-377(octal) i.e. 0-255(decimal).
+  pp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {
+    if (this.regexp_eatOctalDigit(state)) {
+      var n1 = state.lastIntValue;
+      if (this.regexp_eatOctalDigit(state)) {
+        var n2 = state.lastIntValue;
+        if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
+          state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
+        } else {
+          state.lastIntValue = n1 * 8 + n2;
+        }
+      } else {
+        state.lastIntValue = n1;
+      }
+      return true
+    }
+    return false
+  };
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit
+  pp$8.regexp_eatOctalDigit = function(state) {
+    var ch = state.current();
+    if (isOctalDigit(ch)) {
+      state.lastIntValue = ch - 0x30; /* 0 */
+      state.advance();
+      return true
+    }
+    state.lastIntValue = 0;
+    return false
+  };
+  function isOctalDigit(ch) {
+    return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */
+  }
+
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits
+  // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit
+  // And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+  pp$8.regexp_eatFixedHexDigits = function(state, length) {
+    var start = state.pos;
+    state.lastIntValue = 0;
+    for (var i = 0; i < length; ++i) {
+      var ch = state.current();
+      if (!isHexDigit(ch)) {
+        state.pos = start;
+        return false
+      }
+      state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+      state.advance();
+    }
+    return true
+  };
+
+  // Object type used to represent tokens. Note that normally, tokens
+  // simply exist as properties on the parser object. This is only
+  // used for the onToken callback and the external tokenizer.
+
+  var Token = function Token(p) {
+    this.type = p.type;
+    this.value = p.value;
+    this.start = p.start;
+    this.end = p.end;
+    if (p.options.locations)
+      { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
+    if (p.options.ranges)
+      { this.range = [p.start, p.end]; }
+  };
+
+  // ## Tokenizer
+
+  var pp$9 = Parser.prototype;
+
+  // Move to the next token
+
+  pp$9.next = function() {
+    if (this.options.onToken)
+      { this.options.onToken(new Token(this)); }
+
+    this.lastTokEnd = this.end;
+    this.lastTokStart = this.start;
+    this.lastTokEndLoc = this.endLoc;
+    this.lastTokStartLoc = this.startLoc;
+    this.nextToken();
+  };
+
+  pp$9.getToken = function() {
+    this.next();
+    return new Token(this)
+  };
+
+  // If we're in an ES6 environment, make parsers iterable
+  if (typeof Symbol !== "undefined")
+    { pp$9[Symbol.iterator] = function() {
+      var this$1 = this;
+
+      return {
+        next: function () {
+          var token = this$1.getToken();
+          return {
+            done: token.type === types.eof,
+            value: token
+          }
+        }
+      }
+    }; }
+
+  // Toggle strict mode. Re-reads the next number or string to please
+  // pedantic tests (`"use strict"; 010;` should fail).
+
+  pp$9.curContext = function() {
+    return this.context[this.context.length - 1]
+  };
+
+  // Read a single token, updating the parser object's token-related
+  // properties.
+
+  pp$9.nextToken = function() {
+    var curContext = this.curContext();
+    if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
+
+    this.start = this.pos;
+    if (this.options.locations) { this.startLoc = this.curPosition(); }
+    if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+
+    if (curContext.override) { return curContext.override(this) }
+    else { this.readToken(this.fullCharCodeAtPos()); }
+  };
+
+  pp$9.readToken = function(code) {
+    // Identifier or keyword. '\uXXXX' sequences are allowed in
+    // identifiers, so '\' also dispatches to that.
+    if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+      { return this.readWord() }
+
+    return this.getTokenFromCode(code)
+  };
+
+  pp$9.fullCharCodeAtPos = function() {
+    var code = this.input.charCodeAt(this.pos);
+    if (code <= 0xd7ff || code >= 0xe000) { return code }
+    var next = this.input.charCodeAt(this.pos + 1);
+    return (code << 10) + next - 0x35fdc00
+  };
+
+  pp$9.skipBlockComment = function() {
+    var startLoc = this.options.onComment && this.curPosition();
+    var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+    if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
+    this.pos = end + 2;
+    if (this.options.locations) {
+      lineBreakG.lastIndex = start;
+      var match;
+      while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
+        ++this.curLine;
+        this.lineStart = match.index + match[0].length;
+      }
+    }
+    if (this.options.onComment)
+      { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                             startLoc, this.curPosition()); }
+  };
+
+  pp$9.skipLineComment = function(startSkip) {
+    var start = this.pos;
+    var startLoc = this.options.onComment && this.curPosition();
+    var ch = this.input.charCodeAt(this.pos += startSkip);
+    while (this.pos < this.input.length && !isNewLine(ch)) {
+      ch = this.input.charCodeAt(++this.pos);
+    }
+    if (this.options.onComment)
+      { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                             startLoc, this.curPosition()); }
+  };
+
+  // Called at the start of the parse and after every token. Skips
+  // whitespace and comments, and.
+
+  pp$9.skipSpace = function() {
+    loop: while (this.pos < this.input.length) {
+      var ch = this.input.charCodeAt(this.pos);
+      switch (ch) {
+      case 32: case 160: // ' '
+        ++this.pos;
+        break
+      case 13:
+        if (this.input.charCodeAt(this.pos + 1) === 10) {
+          ++this.pos;
+        }
+      case 10: case 8232: case 8233:
+        ++this.pos;
+        if (this.options.locations) {
+          ++this.curLine;
+          this.lineStart = this.pos;
+        }
+        break
+      case 47: // '/'
+        switch (this.input.charCodeAt(this.pos + 1)) {
+        case 42: // '*'
+          this.skipBlockComment();
+          break
+        case 47:
+          this.skipLineComment(2);
+          break
+        default:
+          break loop
+        }
+        break
+      default:
+        if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+          ++this.pos;
+        } else {
+          break loop
+        }
+      }
+    }
+  };
+
+  // Called at the end of every token. Sets `end`, `val`, and
+  // maintains `context` and `exprAllowed`, and skips the space after
+  // the token, so that the next one's `start` will point at the
+  // right position.
+
+  pp$9.finishToken = function(type, val) {
+    this.end = this.pos;
+    if (this.options.locations) { this.endLoc = this.curPosition(); }
+    var prevType = this.type;
+    this.type = type;
+    this.value = val;
+
+    this.updateContext(prevType);
+  };
+
+  // ### Token reading
+
+  // This is the function that is called to fetch the next token. It
+  // is somewhat obscure, because it works in character codes rather
+  // than characters, and because operator parsing has been inlined
+  // into it.
+  //
+  // All in the name of speed.
+  //
+  pp$9.readToken_dot = function() {
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next >= 48 && next <= 57) { return this.readNumber(true) }
+    var next2 = this.input.charCodeAt(this.pos + 2);
+    if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+      this.pos += 3;
+      return this.finishToken(types.ellipsis)
+    } else {
+      ++this.pos;
+      return this.finishToken(types.dot)
+    }
+  };
+
+  pp$9.readToken_slash = function() { // '/'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
+    if (next === 61) { return this.finishOp(types.assign, 2) }
+    return this.finishOp(types.slash, 1)
+  };
+
+  pp$9.readToken_mult_modulo_exp = function(code) { // '%*'
+    var next = this.input.charCodeAt(this.pos + 1);
+    var size = 1;
+    var tokentype = code === 42 ? types.star : types.modulo;
+
+    // exponentiation operator ** and **=
+    if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
+      ++size;
+      tokentype = types.starstar;
+      next = this.input.charCodeAt(this.pos + 2);
+    }
+
+    if (next === 61) { return this.finishOp(types.assign, size + 1) }
+    return this.finishOp(tokentype, size)
+  };
+
+  pp$9.readToken_pipe_amp = function(code) { // '|&'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }
+    if (next === 61) { return this.finishOp(types.assign, 2) }
+    return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
+  };
+
+  pp$9.readToken_caret = function() { // '^'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 61) { return this.finishOp(types.assign, 2) }
+    return this.finishOp(types.bitwiseXOR, 1)
+  };
+
+  pp$9.readToken_plus_min = function(code) { // '+-'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === code) {
+      if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
+          (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
+        // A `-->` line comment
+        this.skipLineComment(3);
+        this.skipSpace();
+        return this.nextToken()
+      }
+      return this.finishOp(types.incDec, 2)
+    }
+    if (next === 61) { return this.finishOp(types.assign, 2) }
+    return this.finishOp(types.plusMin, 1)
+  };
+
+  pp$9.readToken_lt_gt = function(code) { // '<>'
+    var next = this.input.charCodeAt(this.pos + 1);
+    var size = 1;
+    if (next === code) {
+      size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+      if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
+      return this.finishOp(types.bitShift, size)
+    }
+    if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
+        this.input.charCodeAt(this.pos + 3) === 45) {
+      // `<!--`, an XML-style comment that should be interpreted as a line comment
+      this.skipLineComment(4);
+      this.skipSpace();
+      return this.nextToken()
+    }
+    if (next === 61) { size = 2; }
+    return this.finishOp(types.relational, size)
+  };
+
+  pp$9.readToken_eq_excl = function(code) { // '=!'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
+    if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+      this.pos += 2;
+      return this.finishToken(types.arrow)
+    }
+    return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
+  };
+
+  pp$9.getTokenFromCode = function(code) {
+    switch (code) {
+    // The interpretation of a dot depends on whether it is followed
+    // by a digit or another two dots.
+    case 46: // '.'
+      return this.readToken_dot()
+
+    // Punctuation tokens.
+    case 40: ++this.pos; return this.finishToken(types.parenL)
+    case 41: ++this.pos; return this.finishToken(types.parenR)
+    case 59: ++this.pos; return this.finishToken(types.semi)
+    case 44: ++this.pos; return this.finishToken(types.comma)
+    case 91: ++this.pos; return this.finishToken(types.bracketL)
+    case 93: ++this.pos; return this.finishToken(types.bracketR)
+    case 123: ++this.pos; return this.finishToken(types.braceL)
+    case 125: ++this.pos; return this.finishToken(types.braceR)
+    case 58: ++this.pos; return this.finishToken(types.colon)
+    case 63: ++this.pos; return this.finishToken(types.question)
+
+    case 96: // '`'
+      if (this.options.ecmaVersion < 6) { break }
+      ++this.pos;
+      return this.finishToken(types.backQuote)
+
+    case 48: // '0'
+      var next = this.input.charCodeAt(this.pos + 1);
+      if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number
+      if (this.options.ecmaVersion >= 6) {
+        if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number
+        if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number
+      }
+
+    // Anything else beginning with a digit is an integer, octal
+    // number, or float.
+    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
+      return this.readNumber(false)
+
+    // Quotes produce strings.
+    case 34: case 39: // '"', "'"
+      return this.readString(code)
+
+    // Operators are parsed inline in tiny state machines. '=' (61) is
+    // often referred to. `finishOp` simply skips the amount of
+    // characters it is given as second argument, and returns a token
+    // of the type given by its first argument.
+
+    case 47: // '/'
+      return this.readToken_slash()
+
+    case 37: case 42: // '%*'
+      return this.readToken_mult_modulo_exp(code)
+
+    case 124: case 38: // '|&'
+      return this.readToken_pipe_amp(code)
+
+    case 94: // '^'
+      return this.readToken_caret()
+
+    case 43: case 45: // '+-'
+      return this.readToken_plus_min(code)
+
+    case 60: case 62: // '<>'
+      return this.readToken_lt_gt(code)
+
+    case 61: case 33: // '=!'
+      return this.readToken_eq_excl(code)
+
+    case 126: // '~'
+      return this.finishOp(types.prefix, 1)
+    }
+
+    this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+  };
+
+  pp$9.finishOp = function(type, size) {
+    var str = this.input.slice(this.pos, this.pos + size);
+    this.pos += size;
+    return this.finishToken(type, str)
+  };
+
+  pp$9.readRegexp = function() {
+    var escaped, inClass, start = this.pos;
+    for (;;) {
+      if (this.pos >= this.input.length) { this.raise(start, "Unterminated regular expression"); }
+      var ch = this.input.charAt(this.pos);
+      if (lineBreak.test(ch)) { this.raise(start, "Unterminated regular expression"); }
+      if (!escaped) {
+        if (ch === "[") { inClass = true; }
+        else if (ch === "]" && inClass) { inClass = false; }
+        else if (ch === "/" && !inClass) { break }
+        escaped = ch === "\\";
+      } else { escaped = false; }
+      ++this.pos;
+    }
+    var pattern = this.input.slice(start, this.pos);
+    ++this.pos;
+    var flagsStart = this.pos;
+    var flags = this.readWord1();
+    if (this.containsEsc) { this.unexpected(flagsStart); }
+
+    // Validate pattern
+    var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
+    state.reset(start, pattern, flags);
+    this.validateRegExpFlags(state);
+    this.validateRegExpPattern(state);
+
+    // Create Literal#value property value.
+    var value = null;
+    try {
+      value = new RegExp(pattern, flags);
+    } catch (e) {
+      // ESTree requires null if it failed to instantiate RegExp object.
+      // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral
+    }
+
+    return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})
+  };
+
+  // Read an integer in the given radix. Return null if zero digits
+  // were read, the integer value otherwise. When `len` is given, this
+  // will return `null` unless the integer has exactly `len` digits.
+
+  pp$9.readInt = function(radix, len) {
+    var start = this.pos, total = 0;
+    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+      var code = this.input.charCodeAt(this.pos), val = (void 0);
+      if (code >= 97) { val = code - 97 + 10; } // a
+      else if (code >= 65) { val = code - 65 + 10; } // A
+      else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9
+      else { val = Infinity; }
+      if (val >= radix) { break }
+      ++this.pos;
+      total = total * radix + val;
+    }
+    if (this.pos === start || len != null && this.pos - start !== len) { return null }
+
+    return total
+  };
+
+  pp$9.readRadixNumber = function(radix) {
+    var start = this.pos;
+    this.pos += 2; // 0x
+    var val = this.readInt(radix);
+    if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
+    if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
+      val = typeof BigInt !== "undefined" ? BigInt(this.input.slice(start, this.pos)) : null;
+      ++this.pos;
+    } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+    return this.finishToken(types.num, val)
+  };
+
+  // Read an integer, octal integer, or floating-point number.
+
+  pp$9.readNumber = function(startsWithDot) {
+    var start = this.pos;
+    if (!startsWithDot && this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+    var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
+    if (octal && this.strict) { this.raise(start, "Invalid number"); }
+    if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
+    var next = this.input.charCodeAt(this.pos);
+    if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
+      var str$1 = this.input.slice(start, this.pos);
+      var val$1 = typeof BigInt !== "undefined" ? BigInt(str$1) : null;
+      ++this.pos;
+      if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+      return this.finishToken(types.num, val$1)
+    }
+    if (next === 46 && !octal) { // '.'
+      ++this.pos;
+      this.readInt(10);
+      next = this.input.charCodeAt(this.pos);
+    }
+    if ((next === 69 || next === 101) && !octal) { // 'eE'
+      next = this.input.charCodeAt(++this.pos);
+      if (next === 43 || next === 45) { ++this.pos; } // '+-'
+      if (this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+    }
+    if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+
+    var str = this.input.slice(start, this.pos);
+    var val = octal ? parseInt(str, 8) : parseFloat(str);
+    return this.finishToken(types.num, val)
+  };
+
+  // Read a string value, interpreting backslash-escapes.
+
+  pp$9.readCodePoint = function() {
+    var ch = this.input.charCodeAt(this.pos), code;
+
+    if (ch === 123) { // '{'
+      if (this.options.ecmaVersion < 6) { this.unexpected(); }
+      var codePos = ++this.pos;
+      code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
+      ++this.pos;
+      if (code > 0x10FFFF) { this.invalidStringToken(codePos, "Code point out of bounds"); }
+    } else {
+      code = this.readHexChar(4);
+    }
+    return code
+  };
+
+  function codePointToString$1(code) {
+    // UTF-16 Decoding
+    if (code <= 0xFFFF) { return String.fromCharCode(code) }
+    code -= 0x10000;
+    return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
+  }
+
+  pp$9.readString = function(quote) {
+    var out = "", chunkStart = ++this.pos;
+    for (;;) {
+      if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated string constant"); }
+      var ch = this.input.charCodeAt(this.pos);
+      if (ch === quote) { break }
+      if (ch === 92) { // '\'
+        out += this.input.slice(chunkStart, this.pos);
+        out += this.readEscapedChar(false);
+        chunkStart = this.pos;
+      } else {
+        if (isNewLine(ch, this.options.ecmaVersion >= 10)) { this.raise(this.start, "Unterminated string constant"); }
+        ++this.pos;
+      }
+    }
+    out += this.input.slice(chunkStart, this.pos++);
+    return this.finishToken(types.string, out)
+  };
+
+  // Reads template string tokens.
+
+  var INVALID_TEMPLATE_ESCAPE_ERROR = {};
+
+  pp$9.tryReadTemplateToken = function() {
+    this.inTemplateElement = true;
+    try {
+      this.readTmplToken();
+    } catch (err) {
+      if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
+        this.readInvalidTemplateToken();
+      } else {
+        throw err
+      }
+    }
+
+    this.inTemplateElement = false;
+  };
+
+  pp$9.invalidStringToken = function(position, message) {
+    if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
+      throw INVALID_TEMPLATE_ESCAPE_ERROR
+    } else {
+      this.raise(position, message);
+    }
+  };
+
+  pp$9.readTmplToken = function() {
+    var out = "", chunkStart = this.pos;
+    for (;;) {
+      if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated template"); }
+      var ch = this.input.charCodeAt(this.pos);
+      if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
+        if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {
+          if (ch === 36) {
+            this.pos += 2;
+            return this.finishToken(types.dollarBraceL)
+          } else {
+            ++this.pos;
+            return this.finishToken(types.backQuote)
+          }
+        }
+        out += this.input.slice(chunkStart, this.pos);
+        return this.finishToken(types.template, out)
+      }
+      if (ch === 92) { // '\'
+        out += this.input.slice(chunkStart, this.pos);
+        out += this.readEscapedChar(true);
+        chunkStart = this.pos;
+      } else if (isNewLine(ch)) {
+        out += this.input.slice(chunkStart, this.pos);
+        ++this.pos;
+        switch (ch) {
+        case 13:
+          if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }
+        case 10:
+          out += "\n";
+          break
+        default:
+          out += String.fromCharCode(ch);
+          break
+        }
+        if (this.options.locations) {
+          ++this.curLine;
+          this.lineStart = this.pos;
+        }
+        chunkStart = this.pos;
+      } else {
+        ++this.pos;
+      }
+    }
+  };
+
+  // Reads a template token to search for the end, without validating any escape sequences
+  pp$9.readInvalidTemplateToken = function() {
+    for (; this.pos < this.input.length; this.pos++) {
+      switch (this.input[this.pos]) {
+      case "\\":
+        ++this.pos;
+        break
+
+      case "$":
+        if (this.input[this.pos + 1] !== "{") {
+          break
+        }
+      // falls through
+
+      case "`":
+        return this.finishToken(types.invalidTemplate, this.input.slice(this.start, this.pos))
+
+      // no default
+      }
+    }
+    this.raise(this.start, "Unterminated template");
+  };
+
+  // Used to read escaped characters
+
+  pp$9.readEscapedChar = function(inTemplate) {
+    var ch = this.input.charCodeAt(++this.pos);
+    ++this.pos;
+    switch (ch) {
+    case 110: return "\n" // 'n' -> '\n'
+    case 114: return "\r" // 'r' -> '\r'
+    case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'
+    case 117: return codePointToString$1(this.readCodePoint()) // 'u'
+    case 116: return "\t" // 't' -> '\t'
+    case 98: return "\b" // 'b' -> '\b'
+    case 118: return "\u000b" // 'v' -> '\u000b'
+    case 102: return "\f" // 'f' -> '\f'
+    case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\r\n'
+    case 10: // ' \n'
+      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+      return ""
+    default:
+      if (ch >= 48 && ch <= 55) {
+        var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
+        var octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        this.pos += octalStr.length - 1;
+        ch = this.input.charCodeAt(this.pos);
+        if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
+          this.invalidStringToken(
+            this.pos - 1 - octalStr.length,
+            inTemplate
+              ? "Octal literal in template string"
+              : "Octal literal in strict mode"
+          );
+        }
+        return String.fromCharCode(octal)
+      }
+      if (isNewLine(ch)) {
+        // Unicode new line characters after \ get removed from output in both
+        // template literals and strings
+        return ""
+      }
+      return String.fromCharCode(ch)
+    }
+  };
+
+  // Used to read character escape sequences ('\x', '\u', '\U').
+
+  pp$9.readHexChar = function(len) {
+    var codePos = this.pos;
+    var n = this.readInt(16, len);
+    if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
+    return n
+  };
+
+  // Read an identifier, and return it as a string. Sets `this.containsEsc`
+  // to whether the word contained a '\u' escape.
+  //
+  // Incrementally adds only escaped chars, adding other chunks as-is
+  // as a micro-optimization.
+
+  pp$9.readWord1 = function() {
+    this.containsEsc = false;
+    var word = "", first = true, chunkStart = this.pos;
+    var astral = this.options.ecmaVersion >= 6;
+    while (this.pos < this.input.length) {
+      var ch = this.fullCharCodeAtPos();
+      if (isIdentifierChar(ch, astral)) {
+        this.pos += ch <= 0xffff ? 1 : 2;
+      } else if (ch === 92) { // "\"
+        this.containsEsc = true;
+        word += this.input.slice(chunkStart, this.pos);
+        var escStart = this.pos;
+        if (this.input.charCodeAt(++this.pos) !== 117) // "u"
+          { this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX"); }
+        ++this.pos;
+        var esc = this.readCodePoint();
+        if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+          { this.invalidStringToken(escStart, "Invalid Unicode escape"); }
+        word += codePointToString$1(esc);
+        chunkStart = this.pos;
+      } else {
+        break
+      }
+      first = false;
+    }
+    return word + this.input.slice(chunkStart, this.pos)
+  };
+
+  // Read an identifier or keyword token. Will check for reserved
+  // words when necessary.
+
+  pp$9.readWord = function() {
+    var word = this.readWord1();
+    var type = types.name;
+    if (this.keywords.test(word)) {
+      if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword " + word); }
+      type = keywords$1[word];
+    }
+    return this.finishToken(type, word)
+  };
+
+  // Acorn is a tiny, fast JavaScript parser written in JavaScript.
+
+  var version = "6.4.0";
+
+  Parser.acorn = {
+    Parser: Parser,
+    version: version,
+    defaultOptions: defaultOptions,
+    Position: Position,
+    SourceLocation: SourceLocation,
+    getLineInfo: getLineInfo,
+    Node: Node,
+    TokenType: TokenType,
+    tokTypes: types,
+    keywordTypes: keywords$1,
+    TokContext: TokContext,
+    tokContexts: types$1,
+    isIdentifierChar: isIdentifierChar,
+    isIdentifierStart: isIdentifierStart,
+    Token: Token,
+    isNewLine: isNewLine,
+    lineBreak: lineBreak,
+    lineBreakG: lineBreakG,
+    nonASCIIwhitespace: nonASCIIwhitespace
+  };
+
+  // The main exported interface (under `self.acorn` when in the
+  // browser) is a `parse` function that takes a code string and
+  // returns an abstract syntax tree as specified by [Mozilla parser
+  // API][api].
+  //
+  // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+
+  function parse(input, options) {
+    return Parser.parse(input, options)
+  }
+
+  // This function tries to parse a single expression at a given
+  // offset in a string. Useful for parsing mixed-language formats
+  // that embed JavaScript expressions.
+
+  function parseExpressionAt(input, pos, options) {
+    return Parser.parseExpressionAt(input, pos, options)
+  }
+
+  // Acorn is organized as a tokenizer and a recursive-descent parser.
+  // The `tokenizer` export provides an interface to the tokenizer.
+
+  function tokenizer(input, options) {
+    return Parser.tokenizer(input, options)
+  }
+
+  exports.Node = Node;
+  exports.Parser = Parser;
+  exports.Position = Position;
+  exports.SourceLocation = SourceLocation;
+  exports.TokContext = TokContext;
+  exports.Token = Token;
+  exports.TokenType = TokenType;
+  exports.defaultOptions = defaultOptions;
+  exports.getLineInfo = getLineInfo;
+  exports.isIdentifierChar = isIdentifierChar;
+  exports.isIdentifierStart = isIdentifierStart;
+  exports.isNewLine = isNewLine;
+  exports.keywordTypes = keywords$1;
+  exports.lineBreak = lineBreak;
+  exports.lineBreakG = lineBreakG;
+  exports.nonASCIIwhitespace = nonASCIIwhitespace;
+  exports.parse = parse;
+  exports.parseExpressionAt = parseExpressionAt;
+  exports.tokContexts = types$1;
+  exports.tokTypes = types;
+  exports.tokenizer = tokenizer;
+  exports.version = version;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
diff --git a/node_modules/acorn-globals/node_modules/acorn/dist/acorn.js.map b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.js.map
new file mode 100644
index 0000000..7b366e9
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"acorn.js","sources":["../src/identifier.js","../src/tokentype.js","../src/whitespace.js","../src/util.js","../src/locutil.js","../src/options.js","../src/scopeflags.js","../src/state.js","../src/parseutil.js","../src/statement.js","../src/lval.js","../src/expression.js","../src/location.js","../src/scope.js","../src/node.js","../src/tokencontext.js","../src/unicode-property-data.js","../src/regexp.js","../src/tokenize.js","../src/index.js"],"sourcesContent":["// Reserved word lists for various dialects of the language\n\nexport const reservedWords = {\n  3: \"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile\",\n  5: \"class enum extends super const export import\",\n  6: \"enum\",\n  strict: \"implements interface let package private protected public static yield\",\n  strictBind: \"eval arguments\"\n}\n\n// And the keywords\n\nconst ecma5AndLessKeywords = \"break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this\"\n\nexport const keywords = {\n  5: ecma5AndLessKeywords,\n  6: ecma5AndLessKeywords + \" const class extends export import super\"\n}\n\nexport const keywordRelationalOperator = /^in(stanceof)?$/\n\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\n// Generated by `bin/generate-identifier-regex.js`.\n\nlet nonASCIIidentifierStartChars = \"\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u08a0-\\u08b4\\u08b6-\\u08bd\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fef\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7b9\\ua7f7-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab65\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\"\nlet nonASCIIidentifierChars = \"\\u200c\\u200d\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u08d3-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0eb9\\u0ebb\\u0ebc\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf2-\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1df9\\u1dfb-\\u1dff\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\"\n\nconst nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\")\nconst nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\")\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null\n\n// These are a run-length and offset encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by bin/generate-identifier-regex.js\n\n// eslint-disable-next-line comma-spacing\nconst astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,190,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,26,230,43,117,63,32,0,257,0,11,39,8,0,22,0,12,39,3,3,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,68,12,0,67,12,65,1,31,6129,15,754,9486,286,82,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541]\n\n// eslint-disable-next-line comma-spacing\nconst astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,280,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239]\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code, set) {\n  let pos = 0x10000\n  for (let i = 0; i < set.length; i += 2) {\n    pos += set[i]\n    if (pos > code) return false\n    pos += set[i + 1]\n    if (pos >= code) return true\n  }\n}\n\n// Test whether a given character code starts an identifier.\n\nexport function isIdentifierStart(code, astral) {\n  if (code < 65) return code === 36\n  if (code < 91) return true\n  if (code < 97) return code === 95\n  if (code < 123) return true\n  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))\n  if (astral === false) return false\n  return isInAstralSet(code, astralIdentifierStartCodes)\n}\n\n// Test whether a given character is part of an identifier.\n\nexport function isIdentifierChar(code, astral) {\n  if (code < 48) return code === 36\n  if (code < 58) return true\n  if (code < 65) return false\n  if (code < 91) return true\n  if (code < 97) return code === 95\n  if (code < 123) return true\n  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code))\n  if (astral === false) return false\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)\n}\n","// ## Token types\n\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n\n// The `beforeExpr` property is used to disambiguate between regular\n// expressions and divisions. It is set on all token types that can\n// be followed by an expression (thus, a slash after them would be a\n// regular expression).\n//\n// The `startsExpr` property is used to check if the token ends a\n// `yield` expression. It is set on all token types that either can\n// directly start an expression (like a quotation mark) or can\n// continue an expression (like the body of a string).\n//\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\nexport class TokenType {\n  constructor(label, conf = {}) {\n    this.label = label\n    this.keyword = conf.keyword\n    this.beforeExpr = !!conf.beforeExpr\n    this.startsExpr = !!conf.startsExpr\n    this.isLoop = !!conf.isLoop\n    this.isAssign = !!conf.isAssign\n    this.prefix = !!conf.prefix\n    this.postfix = !!conf.postfix\n    this.binop = conf.binop || null\n    this.updateContext = null\n  }\n}\n\nfunction binop(name, prec) {\n  return new TokenType(name, {beforeExpr: true, binop: prec})\n}\nconst beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true}\n\n// Map keyword names to token types.\n\nexport const keywords = {}\n\n// Succinct definitions of keyword token types\nfunction kw(name, options = {}) {\n  options.keyword = name\n  return keywords[name] = new TokenType(name, options)\n}\n\nexport const types = {\n  num: new TokenType(\"num\", startsExpr),\n  regexp: new TokenType(\"regexp\", startsExpr),\n  string: new TokenType(\"string\", startsExpr),\n  name: new TokenType(\"name\", startsExpr),\n  eof: new TokenType(\"eof\"),\n\n  // Punctuation token types.\n  bracketL: new TokenType(\"[\", {beforeExpr: true, startsExpr: true}),\n  bracketR: new TokenType(\"]\"),\n  braceL: new TokenType(\"{\", {beforeExpr: true, startsExpr: true}),\n  braceR: new TokenType(\"}\"),\n  parenL: new TokenType(\"(\", {beforeExpr: true, startsExpr: true}),\n  parenR: new TokenType(\")\"),\n  comma: new TokenType(\",\", beforeExpr),\n  semi: new TokenType(\";\", beforeExpr),\n  colon: new TokenType(\":\", beforeExpr),\n  dot: new TokenType(\".\"),\n  question: new TokenType(\"?\", beforeExpr),\n  arrow: new TokenType(\"=>\", beforeExpr),\n  template: new TokenType(\"template\"),\n  invalidTemplate: new TokenType(\"invalidTemplate\"),\n  ellipsis: new TokenType(\"...\", beforeExpr),\n  backQuote: new TokenType(\"`\", startsExpr),\n  dollarBraceL: new TokenType(\"${\", {beforeExpr: true, startsExpr: true}),\n\n  // Operators. These carry several kinds of properties to help the\n  // parser use them properly (the presence of these properties is\n  // what categorizes them as operators).\n  //\n  // `binop`, when present, specifies that this operator is a binary\n  // operator, and will refer to its precedence.\n  //\n  // `prefix` and `postfix` mark the operator as a prefix or postfix\n  // unary operator.\n  //\n  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n  // binary operators with a very low precedence, that should result\n  // in AssignmentExpression nodes.\n\n  eq: new TokenType(\"=\", {beforeExpr: true, isAssign: true}),\n  assign: new TokenType(\"_=\", {beforeExpr: true, isAssign: true}),\n  incDec: new TokenType(\"++/--\", {prefix: true, postfix: true, startsExpr: true}),\n  prefix: new TokenType(\"!/~\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  logicalOR: binop(\"||\", 1),\n  logicalAND: binop(\"&&\", 2),\n  bitwiseOR: binop(\"|\", 3),\n  bitwiseXOR: binop(\"^\", 4),\n  bitwiseAND: binop(\"&\", 5),\n  equality: binop(\"==/!=/===/!==\", 6),\n  relational: binop(\"</>/<=/>=\", 7),\n  bitShift: binop(\"<</>>/>>>\", 8),\n  plusMin: new TokenType(\"+/-\", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),\n  modulo: binop(\"%\", 10),\n  star: binop(\"*\", 10),\n  slash: binop(\"/\", 10),\n  starstar: new TokenType(\"**\", {beforeExpr: true}),\n\n  // Keyword token types.\n  _break: kw(\"break\"),\n  _case: kw(\"case\", beforeExpr),\n  _catch: kw(\"catch\"),\n  _continue: kw(\"continue\"),\n  _debugger: kw(\"debugger\"),\n  _default: kw(\"default\", beforeExpr),\n  _do: kw(\"do\", {isLoop: true, beforeExpr: true}),\n  _else: kw(\"else\", beforeExpr),\n  _finally: kw(\"finally\"),\n  _for: kw(\"for\", {isLoop: true}),\n  _function: kw(\"function\", startsExpr),\n  _if: kw(\"if\"),\n  _return: kw(\"return\", beforeExpr),\n  _switch: kw(\"switch\"),\n  _throw: kw(\"throw\", beforeExpr),\n  _try: kw(\"try\"),\n  _var: kw(\"var\"),\n  _const: kw(\"const\"),\n  _while: kw(\"while\", {isLoop: true}),\n  _with: kw(\"with\"),\n  _new: kw(\"new\", {beforeExpr: true, startsExpr: true}),\n  _this: kw(\"this\", startsExpr),\n  _super: kw(\"super\", startsExpr),\n  _class: kw(\"class\", startsExpr),\n  _extends: kw(\"extends\", beforeExpr),\n  _export: kw(\"export\"),\n  _import: kw(\"import\"),\n  _null: kw(\"null\", startsExpr),\n  _true: kw(\"true\", startsExpr),\n  _false: kw(\"false\", startsExpr),\n  _in: kw(\"in\", {beforeExpr: true, binop: 7}),\n  _instanceof: kw(\"instanceof\", {beforeExpr: true, binop: 7}),\n  _typeof: kw(\"typeof\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _void: kw(\"void\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _delete: kw(\"delete\", {beforeExpr: true, prefix: true, startsExpr: true})\n}\n","// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\n\nexport const lineBreak = /\\r\\n?|\\n|\\u2028|\\u2029/\nexport const lineBreakG = new RegExp(lineBreak.source, \"g\")\n\nexport function isNewLine(code, ecma2019String) {\n  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))\n}\n\nexport const nonASCIIwhitespace = /[\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff]/\n\nexport const skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g\n","const {hasOwnProperty, toString} = Object.prototype\n\n// Checks if an object has a property.\n\nexport function has(obj, propName) {\n  return hasOwnProperty.call(obj, propName)\n}\n\nexport const isArray = Array.isArray || ((obj) => (\n  toString.call(obj) === \"[object Array]\"\n))\n\nexport function wordsRegexp(words) {\n  return new RegExp(\"^(?:\" + words.replace(/ /g, \"|\") + \")$\")\n}\n","import {lineBreakG} from \"./whitespace\"\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nexport class Position {\n  constructor(line, col) {\n    this.line = line\n    this.column = col\n  }\n\n  offset(n) {\n    return new Position(this.line, this.column + n)\n  }\n}\n\nexport class SourceLocation {\n  constructor(p, start, end) {\n    this.start = start\n    this.end = end\n    if (p.sourceFile !== null) this.source = p.sourceFile\n  }\n}\n\n// The `getLineInfo` function is mostly useful when the\n// `locations` option is off (for performance reasons) and you\n// want to find the line/column position for a given character\n// offset. `input` should be the code string that the offset refers\n// into.\n\nexport function getLineInfo(input, offset) {\n  for (let line = 1, cur = 0;;) {\n    lineBreakG.lastIndex = cur\n    let match = lineBreakG.exec(input)\n    if (match && match.index < offset) {\n      ++line\n      cur = match.index + match[0].length\n    } else {\n      return new Position(line, offset - cur)\n    }\n  }\n}\n","import {has, isArray} from \"./util\"\nimport {SourceLocation} from \"./locutil\"\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nexport const defaultOptions = {\n  // `ecmaVersion` indicates the ECMAScript version to parse. Must be\n  // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10\n  // (2019). This influences support for strict mode, the set of\n  // reserved words, and support for new syntax features. The default\n  // is 9.\n  ecmaVersion: 9,\n  // `sourceType` indicates the mode the code should be parsed in.\n  // Can be either `\"script\"` or `\"module\"`. This influences global\n  // strict mode and parsing of `import` and `export` declarations.\n  sourceType: \"script\",\n  // `onInsertedSemicolon` can be a callback that will be called\n  // when a semicolon is automatically inserted. It will be passed\n  // the position of the comma as an offset, and if `locations` is\n  // enabled, it is given the location as a `{line, column}` object\n  // as second argument.\n  onInsertedSemicolon: null,\n  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for\n  // trailing commas.\n  onTrailingComma: null,\n  // By default, reserved words are only enforced if ecmaVersion >= 5.\n  // Set `allowReserved` to a boolean value to explicitly turn this on\n  // an off. When this option has the value \"never\", reserved words\n  // and keywords can also not be used as property names.\n  allowReserved: null,\n  // When enabled, a return at the top level is not considered an\n  // error.\n  allowReturnOutsideFunction: false,\n  // When enabled, import/export statements are not constrained to\n  // appearing at the top of the program.\n  allowImportExportEverywhere: false,\n  // When enabled, await identifiers are allowed to appear at the top-level scope,\n  // but they are still not allowed in non-async functions.\n  allowAwaitOutsideFunction: false,\n  // When enabled, hashbang directive in the beginning of file\n  // is allowed and treated as a line comment.\n  allowHashBang: false,\n  // When `locations` is on, `loc` properties holding objects with\n  // `start` and `end` properties in `{line, column}` form (with\n  // line being 1-based and column 0-based) will be attached to the\n  // nodes.\n  locations: false,\n  // A function can be passed as `onToken` option, which will\n  // cause Acorn to call that function with object in the same\n  // format as tokens returned from `tokenizer().getToken()`. Note\n  // that you are not allowed to call the parser from the\n  // callback—that will corrupt its internal state.\n  onToken: null,\n  // A function can be passed as `onComment` option, which will\n  // cause Acorn to call that function with `(block, text, start,\n  // end)` parameters whenever a comment is skipped. `block` is a\n  // boolean indicating whether this is a block (`/* */`) comment,\n  // `text` is the content of the comment, and `start` and `end` are\n  // character offsets that denote the start and end of the comment.\n  // When the `locations` option is on, two more parameters are\n  // passed, the full `{line, column}` locations of the start and\n  // end of the comments. Note that you are not allowed to call the\n  // parser from the callback—that will corrupt its internal state.\n  onComment: null,\n  // Nodes have their start and end characters offsets recorded in\n  // `start` and `end` properties (directly on the node, rather than\n  // the `loc` object, which holds line/column data. To also add a\n  // [semi-standardized][range] `range` property holding a `[start,\n  // end]` array with the same numbers, set the `ranges` option to\n  // `true`.\n  //\n  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n  ranges: false,\n  // It is possible to parse multiple files into a single AST by\n  // passing the tree produced by parsing the first file as\n  // `program` option in subsequent parses. This will add the\n  // toplevel forms of the parsed file to the `Program` (top) node\n  // of an existing parse tree.\n  program: null,\n  // When `locations` is on, you can pass this to record the source\n  // file in every node's `loc` object.\n  sourceFile: null,\n  // This value, if given, is stored in every node, whether\n  // `locations` is on or off.\n  directSourceFile: null,\n  // When enabled, parenthesized expressions are represented by\n  // (non-standard) ParenthesizedExpression nodes\n  preserveParens: false\n}\n\n// Interpret and default an options object\n\nexport function getOptions(opts) {\n  let options = {}\n\n  for (let opt in defaultOptions)\n    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]\n\n  if (options.ecmaVersion >= 2015)\n    options.ecmaVersion -= 2009\n\n  if (options.allowReserved == null)\n    options.allowReserved = options.ecmaVersion < 5\n\n  if (isArray(options.onToken)) {\n    let tokens = options.onToken\n    options.onToken = (token) => tokens.push(token)\n  }\n  if (isArray(options.onComment))\n    options.onComment = pushComment(options, options.onComment)\n\n  return options\n}\n\nfunction pushComment(options, array) {\n  return function(block, text, start, end, startLoc, endLoc) {\n    let comment = {\n      type: block ? \"Block\" : \"Line\",\n      value: text,\n      start: start,\n      end: end\n    }\n    if (options.locations)\n      comment.loc = new SourceLocation(this, startLoc, endLoc)\n    if (options.ranges)\n      comment.range = [start, end]\n    array.push(comment)\n  }\n}\n","// Each scope gets a bitset that may contain these flags\nexport const\n    SCOPE_TOP = 1,\n    SCOPE_FUNCTION = 2,\n    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,\n    SCOPE_ASYNC = 4,\n    SCOPE_GENERATOR = 8,\n    SCOPE_ARROW = 16,\n    SCOPE_SIMPLE_CATCH = 32,\n    SCOPE_SUPER = 64,\n    SCOPE_DIRECT_SUPER = 128\n\nexport function functionFlags(async, generator) {\n  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)\n}\n\n// Used in checkLVal and declareName to determine the type of a binding\nexport const\n    BIND_NONE = 0, // Not a binding\n    BIND_VAR = 1, // Var-style binding\n    BIND_LEXICAL = 2, // Let- or const-style binding\n    BIND_FUNCTION = 3, // Function declaration\n    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding\n    BIND_OUTSIDE = 5 // Special case for function names as bound inside the function\n","import {reservedWords, keywords} from \"./identifier\"\nimport {types as tt} from \"./tokentype\"\nimport {lineBreak} from \"./whitespace\"\nimport {getOptions} from \"./options\"\nimport {wordsRegexp} from \"./util\"\nimport {SCOPE_TOP, SCOPE_FUNCTION, SCOPE_ASYNC, SCOPE_GENERATOR, SCOPE_SUPER, SCOPE_DIRECT_SUPER} from \"./scopeflags\"\n\nexport class Parser {\n  constructor(options, input, startPos) {\n    this.options = options = getOptions(options)\n    this.sourceFile = options.sourceFile\n    this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5])\n    let reserved = \"\"\n    if (!options.allowReserved) {\n      for (let v = options.ecmaVersion;; v--)\n        if (reserved = reservedWords[v]) break\n      if (options.sourceType === \"module\") reserved += \" await\"\n    }\n    this.reservedWords = wordsRegexp(reserved)\n    let reservedStrict = (reserved ? reserved + \" \" : \"\") + reservedWords.strict\n    this.reservedWordsStrict = wordsRegexp(reservedStrict)\n    this.reservedWordsStrictBind = wordsRegexp(reservedStrict + \" \" + reservedWords.strictBind)\n    this.input = String(input)\n\n    // Used to signal to callers of `readWord1` whether the word\n    // contained any escape sequences. This is needed because words with\n    // escape sequences must not be interpreted as keywords.\n    this.containsEsc = false\n\n    // Set up token state\n\n    // The current position of the tokenizer in the input.\n    if (startPos) {\n      this.pos = startPos\n      this.lineStart = this.input.lastIndexOf(\"\\n\", startPos - 1) + 1\n      this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length\n    } else {\n      this.pos = this.lineStart = 0\n      this.curLine = 1\n    }\n\n    // Properties of the current token:\n    // Its type\n    this.type = tt.eof\n    // For tokens that include more information than their type, the value\n    this.value = null\n    // Its start and end offset\n    this.start = this.end = this.pos\n    // And, if locations are used, the {line, column} object\n    // corresponding to those offsets\n    this.startLoc = this.endLoc = this.curPosition()\n\n    // Position information for the previous token\n    this.lastTokEndLoc = this.lastTokStartLoc = null\n    this.lastTokStart = this.lastTokEnd = this.pos\n\n    // The context stack is used to superficially track syntactic\n    // context to predict whether a regular expression is allowed in a\n    // given position.\n    this.context = this.initialContext()\n    this.exprAllowed = true\n\n    // Figure out if it's a module code.\n    this.inModule = options.sourceType === \"module\"\n    this.strict = this.inModule || this.strictDirective(this.pos)\n\n    // Used to signify the start of a potential arrow function\n    this.potentialArrowAt = -1\n\n    // Positions to delayed-check that yield/await does not exist in default parameters.\n    this.yieldPos = this.awaitPos = this.awaitIdentPos = 0\n    // Labels in scope.\n    this.labels = []\n    // Thus-far undefined exports.\n    this.undefinedExports = {}\n\n    // If enabled, skip leading hashbang line.\n    if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === \"#!\")\n      this.skipLineComment(2)\n\n    // Scope tracking for duplicate variable names (see scope.js)\n    this.scopeStack = []\n    this.enterScope(SCOPE_TOP)\n\n    // For RegExp validation\n    this.regexpState = null\n  }\n\n  parse() {\n    let node = this.options.program || this.startNode()\n    this.nextToken()\n    return this.parseTopLevel(node)\n  }\n\n  get inFunction() { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 }\n  get inGenerator() { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 }\n  get inAsync() { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 }\n  get allowSuper() { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 }\n  get allowDirectSuper() { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 }\n  get treatFunctionsAsVar() { return this.treatFunctionsAsVarInScope(this.currentScope()) }\n\n  // Switch to a getter for 7.0.0.\n  inNonArrowFunction() { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 }\n\n  static extend(...plugins) {\n    let cls = this\n    for (let i = 0; i < plugins.length; i++) cls = plugins[i](cls)\n    return cls\n  }\n\n  static parse(input, options) {\n    return new this(options, input).parse()\n  }\n\n  static parseExpressionAt(input, pos, options) {\n    let parser = new this(options, input, pos)\n    parser.nextToken()\n    return parser.parseExpression()\n  }\n\n  static tokenizer(input, options) {\n    return new this(options, input)\n  }\n}\n","import {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {lineBreak, skipWhiteSpace} from \"./whitespace\"\n\nconst pp = Parser.prototype\n\n// ## Parser utilities\n\nconst literal = /^(?:'((?:\\\\.|[^'])*?)'|\"((?:\\\\.|[^\"])*?)\")/\npp.strictDirective = function(start) {\n  for (;;) {\n    // Try to find string literal.\n    skipWhiteSpace.lastIndex = start\n    start += skipWhiteSpace.exec(this.input)[0].length\n    let match = literal.exec(this.input.slice(start))\n    if (!match) return false\n    if ((match[1] || match[2]) === \"use strict\") return true\n    start += match[0].length\n\n    // Skip semicolon, if any.\n    skipWhiteSpace.lastIndex = start\n    start += skipWhiteSpace.exec(this.input)[0].length\n    if (this.input[start] === \";\")\n      start++\n  }\n}\n\n// Predicate that tests whether the next token is of the given\n// type, and if yes, consumes it as a side effect.\n\npp.eat = function(type) {\n  if (this.type === type) {\n    this.next()\n    return true\n  } else {\n    return false\n  }\n}\n\n// Tests whether parsed token is a contextual keyword.\n\npp.isContextual = function(name) {\n  return this.type === tt.name && this.value === name && !this.containsEsc\n}\n\n// Consumes contextual keyword if possible.\n\npp.eatContextual = function(name) {\n  if (!this.isContextual(name)) return false\n  this.next()\n  return true\n}\n\n// Asserts that following token is given contextual keyword.\n\npp.expectContextual = function(name) {\n  if (!this.eatContextual(name)) this.unexpected()\n}\n\n// Test whether a semicolon can be inserted at the current position.\n\npp.canInsertSemicolon = function() {\n  return this.type === tt.eof ||\n    this.type === tt.braceR ||\n    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n}\n\npp.insertSemicolon = function() {\n  if (this.canInsertSemicolon()) {\n    if (this.options.onInsertedSemicolon)\n      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)\n    return true\n  }\n}\n\n// Consume a semicolon, or, failing that, see if we are allowed to\n// pretend that there is a semicolon at this position.\n\npp.semicolon = function() {\n  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected()\n}\n\npp.afterTrailingComma = function(tokType, notNext) {\n  if (this.type === tokType) {\n    if (this.options.onTrailingComma)\n      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc)\n    if (!notNext)\n      this.next()\n    return true\n  }\n}\n\n// Expect a token of a given type. If found, consume it, otherwise,\n// raise an unexpected token error.\n\npp.expect = function(type) {\n  this.eat(type) || this.unexpected()\n}\n\n// Raise an unexpected token error.\n\npp.unexpected = function(pos) {\n  this.raise(pos != null ? pos : this.start, \"Unexpected token\")\n}\n\nexport function DestructuringErrors() {\n  this.shorthandAssign =\n  this.trailingComma =\n  this.parenthesizedAssign =\n  this.parenthesizedBind =\n  this.doubleProto =\n    -1\n}\n\npp.checkPatternErrors = function(refDestructuringErrors, isAssign) {\n  if (!refDestructuringErrors) return\n  if (refDestructuringErrors.trailingComma > -1)\n    this.raiseRecoverable(refDestructuringErrors.trailingComma, \"Comma is not permitted after the rest element\")\n  let parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind\n  if (parens > -1) this.raiseRecoverable(parens, \"Parenthesized pattern\")\n}\n\npp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {\n  if (!refDestructuringErrors) return false\n  let {shorthandAssign, doubleProto} = refDestructuringErrors\n  if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0\n  if (shorthandAssign >= 0)\n    this.raise(shorthandAssign, \"Shorthand property assignments are valid only in destructuring patterns\")\n  if (doubleProto >= 0)\n    this.raiseRecoverable(doubleProto, \"Redefinition of __proto__ property\")\n}\n\npp.checkYieldAwaitInDefaultParams = function() {\n  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))\n    this.raise(this.yieldPos, \"Yield expression cannot be a default value\")\n  if (this.awaitPos)\n    this.raise(this.awaitPos, \"Await expression cannot be a default value\")\n}\n\npp.isSimpleAssignTarget = function(expr) {\n  if (expr.type === \"ParenthesizedExpression\")\n    return this.isSimpleAssignTarget(expr.expression)\n  return expr.type === \"Identifier\" || expr.type === \"MemberExpression\"\n}\n","import {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {lineBreak, skipWhiteSpace} from \"./whitespace\"\nimport {isIdentifierStart, isIdentifierChar, keywordRelationalOperator} from \"./identifier\"\nimport {has} from \"./util\"\nimport {DestructuringErrors} from \"./parseutil\"\nimport {functionFlags, SCOPE_SIMPLE_CATCH, BIND_SIMPLE_CATCH, BIND_LEXICAL, BIND_VAR, BIND_FUNCTION} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\n// ### Statement parsing\n\n// Parse a program. Initializes the parser, reads any number of\n// statements, and wraps them in a Program node.  Optionally takes a\n// `program` argument.  If present, the statements will be appended\n// to its body instead of creating a new node.\n\npp.parseTopLevel = function(node) {\n  let exports = {}\n  if (!node.body) node.body = []\n  while (this.type !== tt.eof) {\n    let stmt = this.parseStatement(null, true, exports)\n    node.body.push(stmt)\n  }\n  if (this.inModule)\n    for (let name of Object.keys(this.undefinedExports))\n      this.raiseRecoverable(this.undefinedExports[name].start, `Export '${name}' is not defined`)\n  this.adaptDirectivePrologue(node.body)\n  this.next()\n  if (this.options.ecmaVersion >= 6) {\n    node.sourceType = this.options.sourceType\n  }\n  return this.finishNode(node, \"Program\")\n}\n\nconst loopLabel = {kind: \"loop\"}, switchLabel = {kind: \"switch\"}\n\npp.isLet = function(context) {\n  if (this.options.ecmaVersion < 6 || !this.isContextual(\"let\")) return false\n  skipWhiteSpace.lastIndex = this.pos\n  let skip = skipWhiteSpace.exec(this.input)\n  let next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next)\n  // For ambiguous cases, determine if a LexicalDeclaration (or only a\n  // Statement) is allowed here. If context is not empty then only a Statement\n  // is allowed. However, `let [` is an explicit negative lookahead for\n  // ExpressionStatement, so special-case it first.\n  if (nextCh === 91) return true // '['\n  if (context) return false\n\n  if (nextCh === 123) return true // '{'\n  if (isIdentifierStart(nextCh, true)) {\n    let pos = next + 1\n    while (isIdentifierChar(this.input.charCodeAt(pos), true)) ++pos\n    let ident = this.input.slice(next, pos)\n    if (!keywordRelationalOperator.test(ident)) return true\n  }\n  return false\n}\n\n// check 'async [no LineTerminator here] function'\n// - 'async /*foo*/ function' is OK.\n// - 'async /*\\n*/ function' is invalid.\npp.isAsyncFunction = function() {\n  if (this.options.ecmaVersion < 8 || !this.isContextual(\"async\"))\n    return false\n\n  skipWhiteSpace.lastIndex = this.pos\n  let skip = skipWhiteSpace.exec(this.input)\n  let next = this.pos + skip[0].length\n  return !lineBreak.test(this.input.slice(this.pos, next)) &&\n    this.input.slice(next, next + 8) === \"function\" &&\n    (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))\n}\n\n// Parse a single statement.\n//\n// If expecting a statement and finding a slash operator, parse a\n// regular expression literal. This is to handle cases like\n// `if (foo) /blah/.exec(foo)`, where looking at the previous token\n// does not help.\n\npp.parseStatement = function(context, topLevel, exports) {\n  let starttype = this.type, node = this.startNode(), kind\n\n  if (this.isLet(context)) {\n    starttype = tt._var\n    kind = \"let\"\n  }\n\n  // Most types of statements are recognized by the keyword they\n  // start with. Many are trivial to parse, some require a bit of\n  // complexity.\n\n  switch (starttype) {\n  case tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword)\n  case tt._debugger: return this.parseDebuggerStatement(node)\n  case tt._do: return this.parseDoStatement(node)\n  case tt._for: return this.parseForStatement(node)\n  case tt._function:\n    // Function as sole body of either an if statement or a labeled statement\n    // works, but not when it is part of a labeled statement that is the sole\n    // body of an if statement.\n    if ((context && (this.strict || context !== \"if\" && context !== \"label\")) && this.options.ecmaVersion >= 6) this.unexpected()\n    return this.parseFunctionStatement(node, false, !context)\n  case tt._class:\n    if (context) this.unexpected()\n    return this.parseClass(node, true)\n  case tt._if: return this.parseIfStatement(node)\n  case tt._return: return this.parseReturnStatement(node)\n  case tt._switch: return this.parseSwitchStatement(node)\n  case tt._throw: return this.parseThrowStatement(node)\n  case tt._try: return this.parseTryStatement(node)\n  case tt._const: case tt._var:\n    kind = kind || this.value\n    if (context && kind !== \"var\") this.unexpected()\n    return this.parseVarStatement(node, kind)\n  case tt._while: return this.parseWhileStatement(node)\n  case tt._with: return this.parseWithStatement(node)\n  case tt.braceL: return this.parseBlock(true, node)\n  case tt.semi: return this.parseEmptyStatement(node)\n  case tt._export:\n  case tt._import:\n    if (!this.options.allowImportExportEverywhere) {\n      if (!topLevel)\n        this.raise(this.start, \"'import' and 'export' may only appear at the top level\")\n      if (!this.inModule)\n        this.raise(this.start, \"'import' and 'export' may appear only with 'sourceType: module'\")\n    }\n    return starttype === tt._import ? this.parseImport(node) : this.parseExport(node, exports)\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n  default:\n    if (this.isAsyncFunction()) {\n      if (context) this.unexpected()\n      this.next()\n      return this.parseFunctionStatement(node, true, !context)\n    }\n\n    let maybeName = this.value, expr = this.parseExpression()\n    if (starttype === tt.name && expr.type === \"Identifier\" && this.eat(tt.colon))\n      return this.parseLabeledStatement(node, maybeName, expr, context)\n    else return this.parseExpressionStatement(node, expr)\n  }\n}\n\npp.parseBreakContinueStatement = function(node, keyword) {\n  let isBreak = keyword === \"break\"\n  this.next()\n  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null\n  else if (this.type !== tt.name) this.unexpected()\n  else {\n    node.label = this.parseIdent()\n    this.semicolon()\n  }\n\n  // Verify that there is an actual destination to break or\n  // continue to.\n  let i = 0\n  for (; i < this.labels.length; ++i) {\n    let lab = this.labels[i]\n    if (node.label == null || lab.name === node.label.name) {\n      if (lab.kind != null && (isBreak || lab.kind === \"loop\")) break\n      if (node.label && isBreak) break\n    }\n  }\n  if (i === this.labels.length) this.raise(node.start, \"Unsyntactic \" + keyword)\n  return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\")\n}\n\npp.parseDebuggerStatement = function(node) {\n  this.next()\n  this.semicolon()\n  return this.finishNode(node, \"DebuggerStatement\")\n}\n\npp.parseDoStatement = function(node) {\n  this.next()\n  this.labels.push(loopLabel)\n  node.body = this.parseStatement(\"do\")\n  this.labels.pop()\n  this.expect(tt._while)\n  node.test = this.parseParenExpression()\n  if (this.options.ecmaVersion >= 6)\n    this.eat(tt.semi)\n  else\n    this.semicolon()\n  return this.finishNode(node, \"DoWhileStatement\")\n}\n\n// Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n// loop is non-trivial. Basically, we have to parse the init `var`\n// statement or expression, disallowing the `in` operator (see\n// the second parameter to `parseExpression`), and then check\n// whether the next token is `in` or `of`. When there is no init\n// part (semicolon immediately after the opening parenthesis), it\n// is a regular `for` loop.\n\npp.parseForStatement = function(node) {\n  this.next()\n  let awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual(\"await\")) ? this.lastTokStart : -1\n  this.labels.push(loopLabel)\n  this.enterScope(0)\n  this.expect(tt.parenL)\n  if (this.type === tt.semi) {\n    if (awaitAt > -1) this.unexpected(awaitAt)\n    return this.parseFor(node, null)\n  }\n  let isLet = this.isLet()\n  if (this.type === tt._var || this.type === tt._const || isLet) {\n    let init = this.startNode(), kind = isLet ? \"let\" : this.value\n    this.next()\n    this.parseVar(init, true, kind)\n    this.finishNode(init, \"VariableDeclaration\")\n    if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) && init.declarations.length === 1 &&\n        !(kind !== \"var\" && init.declarations[0].init)) {\n      if (this.options.ecmaVersion >= 9) {\n        if (this.type === tt._in) {\n          if (awaitAt > -1) this.unexpected(awaitAt)\n        } else node.await = awaitAt > -1\n      }\n      return this.parseForIn(node, init)\n    }\n    if (awaitAt > -1) this.unexpected(awaitAt)\n    return this.parseFor(node, init)\n  }\n  let refDestructuringErrors = new DestructuringErrors\n  let init = this.parseExpression(true, refDestructuringErrors)\n  if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) {\n    if (this.options.ecmaVersion >= 9) {\n      if (this.type === tt._in) {\n        if (awaitAt > -1) this.unexpected(awaitAt)\n      } else node.await = awaitAt > -1\n    }\n    this.toAssignable(init, false, refDestructuringErrors)\n    this.checkLVal(init)\n    return this.parseForIn(node, init)\n  } else {\n    this.checkExpressionErrors(refDestructuringErrors, true)\n  }\n  if (awaitAt > -1) this.unexpected(awaitAt)\n  return this.parseFor(node, init)\n}\n\npp.parseFunctionStatement = function(node, isAsync, declarationPosition) {\n  this.next()\n  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)\n}\n\npp.parseIfStatement = function(node) {\n  this.next()\n  node.test = this.parseParenExpression()\n  // allow function declarations in branches, but only in non-strict mode\n  node.consequent = this.parseStatement(\"if\")\n  node.alternate = this.eat(tt._else) ? this.parseStatement(\"if\") : null\n  return this.finishNode(node, \"IfStatement\")\n}\n\npp.parseReturnStatement = function(node) {\n  if (!this.inFunction && !this.options.allowReturnOutsideFunction)\n    this.raise(this.start, \"'return' outside of function\")\n  this.next()\n\n  // In `return` (and `break`/`continue`), the keywords with\n  // optional arguments, we eagerly look for a semicolon or the\n  // possibility to insert one.\n\n  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null\n  else { node.argument = this.parseExpression(); this.semicolon() }\n  return this.finishNode(node, \"ReturnStatement\")\n}\n\npp.parseSwitchStatement = function(node) {\n  this.next()\n  node.discriminant = this.parseParenExpression()\n  node.cases = []\n  this.expect(tt.braceL)\n  this.labels.push(switchLabel)\n  this.enterScope(0)\n\n  // Statements under must be grouped (by label) in SwitchCase\n  // nodes. `cur` is used to keep the node that we are currently\n  // adding statements to.\n\n  let cur\n  for (let sawDefault = false; this.type !== tt.braceR;) {\n    if (this.type === tt._case || this.type === tt._default) {\n      let isCase = this.type === tt._case\n      if (cur) this.finishNode(cur, \"SwitchCase\")\n      node.cases.push(cur = this.startNode())\n      cur.consequent = []\n      this.next()\n      if (isCase) {\n        cur.test = this.parseExpression()\n      } else {\n        if (sawDefault) this.raiseRecoverable(this.lastTokStart, \"Multiple default clauses\")\n        sawDefault = true\n        cur.test = null\n      }\n      this.expect(tt.colon)\n    } else {\n      if (!cur) this.unexpected()\n      cur.consequent.push(this.parseStatement(null))\n    }\n  }\n  this.exitScope()\n  if (cur) this.finishNode(cur, \"SwitchCase\")\n  this.next() // Closing brace\n  this.labels.pop()\n  return this.finishNode(node, \"SwitchStatement\")\n}\n\npp.parseThrowStatement = function(node) {\n  this.next()\n  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))\n    this.raise(this.lastTokEnd, \"Illegal newline after throw\")\n  node.argument = this.parseExpression()\n  this.semicolon()\n  return this.finishNode(node, \"ThrowStatement\")\n}\n\n// Reused empty array added for node fields that are always empty.\n\nconst empty = []\n\npp.parseTryStatement = function(node) {\n  this.next()\n  node.block = this.parseBlock()\n  node.handler = null\n  if (this.type === tt._catch) {\n    let clause = this.startNode()\n    this.next()\n    if (this.eat(tt.parenL)) {\n      clause.param = this.parseBindingAtom()\n      let simple = clause.param.type === \"Identifier\"\n      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0)\n      this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL)\n      this.expect(tt.parenR)\n    } else {\n      if (this.options.ecmaVersion < 10) this.unexpected()\n      clause.param = null\n      this.enterScope(0)\n    }\n    clause.body = this.parseBlock(false)\n    this.exitScope()\n    node.handler = this.finishNode(clause, \"CatchClause\")\n  }\n  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null\n  if (!node.handler && !node.finalizer)\n    this.raise(node.start, \"Missing catch or finally clause\")\n  return this.finishNode(node, \"TryStatement\")\n}\n\npp.parseVarStatement = function(node, kind) {\n  this.next()\n  this.parseVar(node, false, kind)\n  this.semicolon()\n  return this.finishNode(node, \"VariableDeclaration\")\n}\n\npp.parseWhileStatement = function(node) {\n  this.next()\n  node.test = this.parseParenExpression()\n  this.labels.push(loopLabel)\n  node.body = this.parseStatement(\"while\")\n  this.labels.pop()\n  return this.finishNode(node, \"WhileStatement\")\n}\n\npp.parseWithStatement = function(node) {\n  if (this.strict) this.raise(this.start, \"'with' in strict mode\")\n  this.next()\n  node.object = this.parseParenExpression()\n  node.body = this.parseStatement(\"with\")\n  return this.finishNode(node, \"WithStatement\")\n}\n\npp.parseEmptyStatement = function(node) {\n  this.next()\n  return this.finishNode(node, \"EmptyStatement\")\n}\n\npp.parseLabeledStatement = function(node, maybeName, expr, context) {\n  for (let label of this.labels)\n    if (label.name === maybeName)\n      this.raise(expr.start, \"Label '\" + maybeName + \"' is already declared\")\n  let kind = this.type.isLoop ? \"loop\" : this.type === tt._switch ? \"switch\" : null\n  for (let i = this.labels.length - 1; i >= 0; i--) {\n    let label = this.labels[i]\n    if (label.statementStart === node.start) {\n      // Update information about previous labels on this node\n      label.statementStart = this.start\n      label.kind = kind\n    } else break\n  }\n  this.labels.push({name: maybeName, kind, statementStart: this.start})\n  node.body = this.parseStatement(context ? context.indexOf(\"label\") === -1 ? context + \"label\" : context : \"label\")\n  this.labels.pop()\n  node.label = expr\n  return this.finishNode(node, \"LabeledStatement\")\n}\n\npp.parseExpressionStatement = function(node, expr) {\n  node.expression = expr\n  this.semicolon()\n  return this.finishNode(node, \"ExpressionStatement\")\n}\n\n// Parse a semicolon-enclosed block of statements, handling `\"use\n// strict\"` declarations when `allowStrict` is true (used for\n// function bodies).\n\npp.parseBlock = function(createNewLexicalScope = true, node = this.startNode()) {\n  node.body = []\n  this.expect(tt.braceL)\n  if (createNewLexicalScope) this.enterScope(0)\n  while (!this.eat(tt.braceR)) {\n    let stmt = this.parseStatement(null)\n    node.body.push(stmt)\n  }\n  if (createNewLexicalScope) this.exitScope()\n  return this.finishNode(node, \"BlockStatement\")\n}\n\n// Parse a regular `for` loop. The disambiguation code in\n// `parseStatement` will already have parsed the init statement or\n// expression.\n\npp.parseFor = function(node, init) {\n  node.init = init\n  this.expect(tt.semi)\n  node.test = this.type === tt.semi ? null : this.parseExpression()\n  this.expect(tt.semi)\n  node.update = this.type === tt.parenR ? null : this.parseExpression()\n  this.expect(tt.parenR)\n  node.body = this.parseStatement(\"for\")\n  this.exitScope()\n  this.labels.pop()\n  return this.finishNode(node, \"ForStatement\")\n}\n\n// Parse a `for`/`in` and `for`/`of` loop, which are almost\n// same from parser's perspective.\n\npp.parseForIn = function(node, init) {\n  let type = this.type === tt._in ? \"ForInStatement\" : \"ForOfStatement\"\n  this.next()\n  if (type === \"ForInStatement\") {\n    if (init.type === \"AssignmentPattern\" ||\n      (init.type === \"VariableDeclaration\" && init.declarations[0].init != null &&\n       (this.strict || init.declarations[0].id.type !== \"Identifier\")))\n      this.raise(init.start, \"Invalid assignment in for-in loop head\")\n  }\n  node.left = init\n  node.right = type === \"ForInStatement\" ? this.parseExpression() : this.parseMaybeAssign()\n  this.expect(tt.parenR)\n  node.body = this.parseStatement(\"for\")\n  this.exitScope()\n  this.labels.pop()\n  return this.finishNode(node, type)\n}\n\n// Parse a list of variable declarations.\n\npp.parseVar = function(node, isFor, kind) {\n  node.declarations = []\n  node.kind = kind\n  for (;;) {\n    let decl = this.startNode()\n    this.parseVarId(decl, kind)\n    if (this.eat(tt.eq)) {\n      decl.init = this.parseMaybeAssign(isFor)\n    } else if (kind === \"const\" && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\")))) {\n      this.unexpected()\n    } else if (decl.id.type !== \"Identifier\" && !(isFor && (this.type === tt._in || this.isContextual(\"of\")))) {\n      this.raise(this.lastTokEnd, \"Complex binding patterns require an initialization value\")\n    } else {\n      decl.init = null\n    }\n    node.declarations.push(this.finishNode(decl, \"VariableDeclarator\"))\n    if (!this.eat(tt.comma)) break\n  }\n  return node\n}\n\npp.parseVarId = function(decl, kind) {\n  if ((kind === \"const\" || kind === \"let\") && this.isContextual(\"let\")) {\n    this.raiseRecoverable(this.start, \"let is disallowed as a lexically bound name\")\n  }\n  decl.id = this.parseBindingAtom()\n  this.checkLVal(decl.id, kind === \"var\" ? BIND_VAR : BIND_LEXICAL, false)\n}\n\nconst FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4\n\n// Parse a function declaration or literal (depending on the\n// `statement & FUNC_STATEMENT`).\n\n// Remove `allowExpressionBody` for 7.0.0, as it is only called with false\npp.parseFunction = function(node, statement, allowExpressionBody, isAsync) {\n  this.initFunction(node)\n  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {\n    if (this.type === tt.star && (statement & FUNC_HANGING_STATEMENT))\n      this.unexpected()\n    node.generator = this.eat(tt.star)\n  }\n  if (this.options.ecmaVersion >= 8)\n    node.async = !!isAsync\n\n  if (statement & FUNC_STATEMENT) {\n    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== tt.name ? null : this.parseIdent()\n    if (node.id && !(statement & FUNC_HANGING_STATEMENT))\n      // If it is a regular function declaration in sloppy mode, then it is\n      // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding\n      // mode depends on properties of the current scope (see\n      // treatFunctionsAsVar).\n      this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION)\n  }\n\n  let oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n  this.yieldPos = 0\n  this.awaitPos = 0\n  this.awaitIdentPos = 0\n  this.enterScope(functionFlags(node.async, node.generator))\n\n  if (!(statement & FUNC_STATEMENT))\n    node.id = this.type === tt.name ? this.parseIdent() : null\n\n  this.parseFunctionParams(node)\n  this.parseFunctionBody(node, allowExpressionBody, false)\n\n  this.yieldPos = oldYieldPos\n  this.awaitPos = oldAwaitPos\n  this.awaitIdentPos = oldAwaitIdentPos\n  return this.finishNode(node, (statement & FUNC_STATEMENT) ? \"FunctionDeclaration\" : \"FunctionExpression\")\n}\n\npp.parseFunctionParams = function(node) {\n  this.expect(tt.parenL)\n  node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8)\n  this.checkYieldAwaitInDefaultParams()\n}\n\n// Parse a class declaration or literal (depending on the\n// `isStatement` parameter).\n\npp.parseClass = function(node, isStatement) {\n  this.next()\n\n  // ecma-262 14.6 Class Definitions\n  // A class definition is always strict mode code.\n  const oldStrict = this.strict\n  this.strict = true\n\n  this.parseClassId(node, isStatement)\n  this.parseClassSuper(node)\n  let classBody = this.startNode()\n  let hadConstructor = false\n  classBody.body = []\n  this.expect(tt.braceL)\n  while (!this.eat(tt.braceR)) {\n    const element = this.parseClassElement(node.superClass !== null)\n    if (element) {\n      classBody.body.push(element)\n      if (element.type === \"MethodDefinition\" && element.kind === \"constructor\") {\n        if (hadConstructor) this.raise(element.start, \"Duplicate constructor in the same class\")\n        hadConstructor = true\n      }\n    }\n  }\n  node.body = this.finishNode(classBody, \"ClassBody\")\n  this.strict = oldStrict\n  return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\")\n}\n\npp.parseClassElement = function(constructorAllowsSuper) {\n  if (this.eat(tt.semi)) return null\n\n  let method = this.startNode()\n  const tryContextual = (k, noLineBreak = false) => {\n    const start = this.start, startLoc = this.startLoc\n    if (!this.eatContextual(k)) return false\n    if (this.type !== tt.parenL && (!noLineBreak || !this.canInsertSemicolon())) return true\n    if (method.key) this.unexpected()\n    method.computed = false\n    method.key = this.startNodeAt(start, startLoc)\n    method.key.name = k\n    this.finishNode(method.key, \"Identifier\")\n    return false\n  }\n\n  method.kind = \"method\"\n  method.static = tryContextual(\"static\")\n  let isGenerator = this.eat(tt.star)\n  let isAsync = false\n  if (!isGenerator) {\n    if (this.options.ecmaVersion >= 8 && tryContextual(\"async\", true)) {\n      isAsync = true\n      isGenerator = this.options.ecmaVersion >= 9 && this.eat(tt.star)\n    } else if (tryContextual(\"get\")) {\n      method.kind = \"get\"\n    } else if (tryContextual(\"set\")) {\n      method.kind = \"set\"\n    }\n  }\n  if (!method.key) this.parsePropertyName(method)\n  let {key} = method\n  let allowsDirectSuper = false\n  if (!method.computed && !method.static && (key.type === \"Identifier\" && key.name === \"constructor\" ||\n      key.type === \"Literal\" && key.value === \"constructor\")) {\n    if (method.kind !== \"method\") this.raise(key.start, \"Constructor can't have get/set modifier\")\n    if (isGenerator) this.raise(key.start, \"Constructor can't be a generator\")\n    if (isAsync) this.raise(key.start, \"Constructor can't be an async method\")\n    method.kind = \"constructor\"\n    allowsDirectSuper = constructorAllowsSuper\n  } else if (method.static && key.type === \"Identifier\" && key.name === \"prototype\") {\n    this.raise(key.start, \"Classes may not have a static property named prototype\")\n  }\n  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper)\n  if (method.kind === \"get\" && method.value.params.length !== 0)\n    this.raiseRecoverable(method.value.start, \"getter should have no params\")\n  if (method.kind === \"set\" && method.value.params.length !== 1)\n    this.raiseRecoverable(method.value.start, \"setter should have exactly one param\")\n  if (method.kind === \"set\" && method.value.params[0].type === \"RestElement\")\n    this.raiseRecoverable(method.value.params[0].start, \"Setter cannot use rest params\")\n  return method\n}\n\npp.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {\n  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper)\n  return this.finishNode(method, \"MethodDefinition\")\n}\n\npp.parseClassId = function(node, isStatement) {\n  if (this.type === tt.name) {\n    node.id = this.parseIdent()\n    if (isStatement)\n      this.checkLVal(node.id, BIND_LEXICAL, false)\n  } else {\n    if (isStatement === true)\n      this.unexpected()\n    node.id = null\n  }\n}\n\npp.parseClassSuper = function(node) {\n  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null\n}\n\n// Parses module export declaration.\n\npp.parseExport = function(node, exports) {\n  this.next()\n  // export * from '...'\n  if (this.eat(tt.star)) {\n    this.expectContextual(\"from\")\n    if (this.type !== tt.string) this.unexpected()\n    node.source = this.parseExprAtom()\n    this.semicolon()\n    return this.finishNode(node, \"ExportAllDeclaration\")\n  }\n  if (this.eat(tt._default)) { // export default ...\n    this.checkExport(exports, \"default\", this.lastTokStart)\n    let isAsync\n    if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {\n      let fNode = this.startNode()\n      this.next()\n      if (isAsync) this.next()\n      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync)\n    } else if (this.type === tt._class) {\n      let cNode = this.startNode()\n      node.declaration = this.parseClass(cNode, \"nullableID\")\n    } else {\n      node.declaration = this.parseMaybeAssign()\n      this.semicolon()\n    }\n    return this.finishNode(node, \"ExportDefaultDeclaration\")\n  }\n  // export var|const|let|function|class ...\n  if (this.shouldParseExportStatement()) {\n    node.declaration = this.parseStatement(null)\n    if (node.declaration.type === \"VariableDeclaration\")\n      this.checkVariableExport(exports, node.declaration.declarations)\n    else\n      this.checkExport(exports, node.declaration.id.name, node.declaration.id.start)\n    node.specifiers = []\n    node.source = null\n  } else { // export { x, y as z } [from '...']\n    node.declaration = null\n    node.specifiers = this.parseExportSpecifiers(exports)\n    if (this.eatContextual(\"from\")) {\n      if (this.type !== tt.string) this.unexpected()\n      node.source = this.parseExprAtom()\n    } else {\n      for (let spec of node.specifiers) {\n        // check for keywords used as local names\n        this.checkUnreserved(spec.local)\n        // check if export is defined\n        this.checkLocalExport(spec.local)\n      }\n\n      node.source = null\n    }\n    this.semicolon()\n  }\n  return this.finishNode(node, \"ExportNamedDeclaration\")\n}\n\npp.checkExport = function(exports, name, pos) {\n  if (!exports) return\n  if (has(exports, name))\n    this.raiseRecoverable(pos, \"Duplicate export '\" + name + \"'\")\n  exports[name] = true\n}\n\npp.checkPatternExport = function(exports, pat) {\n  let type = pat.type\n  if (type === \"Identifier\")\n    this.checkExport(exports, pat.name, pat.start)\n  else if (type === \"ObjectPattern\")\n    for (let prop of pat.properties)\n      this.checkPatternExport(exports, prop)\n  else if (type === \"ArrayPattern\")\n    for (let elt of pat.elements) {\n      if (elt) this.checkPatternExport(exports, elt)\n    }\n  else if (type === \"Property\")\n    this.checkPatternExport(exports, pat.value)\n  else if (type === \"AssignmentPattern\")\n    this.checkPatternExport(exports, pat.left)\n  else if (type === \"RestElement\")\n    this.checkPatternExport(exports, pat.argument)\n  else if (type === \"ParenthesizedExpression\")\n    this.checkPatternExport(exports, pat.expression)\n}\n\npp.checkVariableExport = function(exports, decls) {\n  if (!exports) return\n  for (let decl of decls)\n    this.checkPatternExport(exports, decl.id)\n}\n\npp.shouldParseExportStatement = function() {\n  return this.type.keyword === \"var\" ||\n    this.type.keyword === \"const\" ||\n    this.type.keyword === \"class\" ||\n    this.type.keyword === \"function\" ||\n    this.isLet() ||\n    this.isAsyncFunction()\n}\n\n// Parses a comma-separated list of module exports.\n\npp.parseExportSpecifiers = function(exports) {\n  let nodes = [], first = true\n  // export { x, y as z } [from '...']\n  this.expect(tt.braceL)\n  while (!this.eat(tt.braceR)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (this.afterTrailingComma(tt.braceR)) break\n    } else first = false\n\n    let node = this.startNode()\n    node.local = this.parseIdent(true)\n    node.exported = this.eatContextual(\"as\") ? this.parseIdent(true) : node.local\n    this.checkExport(exports, node.exported.name, node.exported.start)\n    nodes.push(this.finishNode(node, \"ExportSpecifier\"))\n  }\n  return nodes\n}\n\n// Parses import declaration.\n\npp.parseImport = function(node) {\n  this.next()\n  // import '...'\n  if (this.type === tt.string) {\n    node.specifiers = empty\n    node.source = this.parseExprAtom()\n  } else {\n    node.specifiers = this.parseImportSpecifiers()\n    this.expectContextual(\"from\")\n    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()\n  }\n  this.semicolon()\n  return this.finishNode(node, \"ImportDeclaration\")\n}\n\n// Parses a comma-separated list of module imports.\n\npp.parseImportSpecifiers = function() {\n  let nodes = [], first = true\n  if (this.type === tt.name) {\n    // import defaultObj, { x, y as z } from '...'\n    let node = this.startNode()\n    node.local = this.parseIdent()\n    this.checkLVal(node.local, BIND_LEXICAL)\n    nodes.push(this.finishNode(node, \"ImportDefaultSpecifier\"))\n    if (!this.eat(tt.comma)) return nodes\n  }\n  if (this.type === tt.star) {\n    let node = this.startNode()\n    this.next()\n    this.expectContextual(\"as\")\n    node.local = this.parseIdent()\n    this.checkLVal(node.local, BIND_LEXICAL)\n    nodes.push(this.finishNode(node, \"ImportNamespaceSpecifier\"))\n    return nodes\n  }\n  this.expect(tt.braceL)\n  while (!this.eat(tt.braceR)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (this.afterTrailingComma(tt.braceR)) break\n    } else first = false\n\n    let node = this.startNode()\n    node.imported = this.parseIdent(true)\n    if (this.eatContextual(\"as\")) {\n      node.local = this.parseIdent()\n    } else {\n      this.checkUnreserved(node.imported)\n      node.local = node.imported\n    }\n    this.checkLVal(node.local, BIND_LEXICAL)\n    nodes.push(this.finishNode(node, \"ImportSpecifier\"))\n  }\n  return nodes\n}\n\n// Set `ExpressionStatement#directive` property for directive prologues.\npp.adaptDirectivePrologue = function(statements) {\n  for (let i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {\n    statements[i].directive = statements[i].expression.raw.slice(1, -1)\n  }\n}\npp.isDirectiveCandidate = function(statement) {\n  return (\n    statement.type === \"ExpressionStatement\" &&\n    statement.expression.type === \"Literal\" &&\n    typeof statement.expression.value === \"string\" &&\n    // Reject parenthesized strings.\n    (this.input[statement.start] === \"\\\"\" || this.input[statement.start] === \"'\")\n  )\n}\n","import {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {has} from \"./util\"\nimport {BIND_NONE, BIND_OUTSIDE} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\n// Convert existing expression atom to assignable pattern\n// if possible.\n\npp.toAssignable = function(node, isBinding, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 6 && node) {\n    switch (node.type) {\n    case \"Identifier\":\n      if (this.inAsync && node.name === \"await\")\n        this.raise(node.start, \"Cannot use 'await' as identifier inside an async function\")\n      break\n\n    case \"ObjectPattern\":\n    case \"ArrayPattern\":\n    case \"RestElement\":\n      break\n\n    case \"ObjectExpression\":\n      node.type = \"ObjectPattern\"\n      if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true)\n      for (let prop of node.properties) {\n        this.toAssignable(prop, isBinding)\n        // Early error:\n        //   AssignmentRestProperty[Yield, Await] :\n        //     `...` DestructuringAssignmentTarget[Yield, Await]\n        //\n        //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.\n        if (\n          prop.type === \"RestElement\" &&\n          (prop.argument.type === \"ArrayPattern\" || prop.argument.type === \"ObjectPattern\")\n        ) {\n          this.raise(prop.argument.start, \"Unexpected token\")\n        }\n      }\n      break\n\n    case \"Property\":\n      // AssignmentProperty has type === \"Property\"\n      if (node.kind !== \"init\") this.raise(node.key.start, \"Object pattern can't contain getter or setter\")\n      this.toAssignable(node.value, isBinding)\n      break\n\n    case \"ArrayExpression\":\n      node.type = \"ArrayPattern\"\n      if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true)\n      this.toAssignableList(node.elements, isBinding)\n      break\n\n    case \"SpreadElement\":\n      node.type = \"RestElement\"\n      this.toAssignable(node.argument, isBinding)\n      if (node.argument.type === \"AssignmentPattern\")\n        this.raise(node.argument.start, \"Rest elements cannot have a default value\")\n      break\n\n    case \"AssignmentExpression\":\n      if (node.operator !== \"=\") this.raise(node.left.end, \"Only '=' operator can be used for specifying default value.\")\n      node.type = \"AssignmentPattern\"\n      delete node.operator\n      this.toAssignable(node.left, isBinding)\n      // falls through to AssignmentPattern\n\n    case \"AssignmentPattern\":\n      break\n\n    case \"ParenthesizedExpression\":\n      this.toAssignable(node.expression, isBinding, refDestructuringErrors)\n      break\n\n    case \"MemberExpression\":\n      if (!isBinding) break\n\n    default:\n      this.raise(node.start, \"Assigning to rvalue\")\n    }\n  } else if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true)\n  return node\n}\n\n// Convert list of expression atoms to binding list.\n\npp.toAssignableList = function(exprList, isBinding) {\n  let end = exprList.length\n  for (let i = 0; i < end; i++) {\n    let elt = exprList[i]\n    if (elt) this.toAssignable(elt, isBinding)\n  }\n  if (end) {\n    let last = exprList[end - 1]\n    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === \"RestElement\" && last.argument.type !== \"Identifier\")\n      this.unexpected(last.argument.start)\n  }\n  return exprList\n}\n\n// Parses spread element.\n\npp.parseSpread = function(refDestructuringErrors) {\n  let node = this.startNode()\n  this.next()\n  node.argument = this.parseMaybeAssign(false, refDestructuringErrors)\n  return this.finishNode(node, \"SpreadElement\")\n}\n\npp.parseRestBinding = function() {\n  let node = this.startNode()\n  this.next()\n\n  // RestElement inside of a function parameter must be an identifier\n  if (this.options.ecmaVersion === 6 && this.type !== tt.name)\n    this.unexpected()\n\n  node.argument = this.parseBindingAtom()\n\n  return this.finishNode(node, \"RestElement\")\n}\n\n// Parses lvalue (assignable) atom.\n\npp.parseBindingAtom = function() {\n  if (this.options.ecmaVersion >= 6) {\n    switch (this.type) {\n    case tt.bracketL:\n      let node = this.startNode()\n      this.next()\n      node.elements = this.parseBindingList(tt.bracketR, true, true)\n      return this.finishNode(node, \"ArrayPattern\")\n\n    case tt.braceL:\n      return this.parseObj(true)\n    }\n  }\n  return this.parseIdent()\n}\n\npp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {\n  let elts = [], first = true\n  while (!this.eat(close)) {\n    if (first) first = false\n    else this.expect(tt.comma)\n    if (allowEmpty && this.type === tt.comma) {\n      elts.push(null)\n    } else if (allowTrailingComma && this.afterTrailingComma(close)) {\n      break\n    } else if (this.type === tt.ellipsis) {\n      let rest = this.parseRestBinding()\n      this.parseBindingListItem(rest)\n      elts.push(rest)\n      if (this.type === tt.comma) this.raise(this.start, \"Comma is not permitted after the rest element\")\n      this.expect(close)\n      break\n    } else {\n      let elem = this.parseMaybeDefault(this.start, this.startLoc)\n      this.parseBindingListItem(elem)\n      elts.push(elem)\n    }\n  }\n  return elts\n}\n\npp.parseBindingListItem = function(param) {\n  return param\n}\n\n// Parses assignment pattern around given atom if possible.\n\npp.parseMaybeDefault = function(startPos, startLoc, left) {\n  left = left || this.parseBindingAtom()\n  if (this.options.ecmaVersion < 6 || !this.eat(tt.eq)) return left\n  let node = this.startNodeAt(startPos, startLoc)\n  node.left = left\n  node.right = this.parseMaybeAssign()\n  return this.finishNode(node, \"AssignmentPattern\")\n}\n\n// Verify that a node is an lval — something that can be assigned\n// to.\n// bindingType can be either:\n// 'var' indicating that the lval creates a 'var' binding\n// 'let' indicating that the lval creates a lexical ('let' or 'const') binding\n// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references\n\npp.checkLVal = function(expr, bindingType = BIND_NONE, checkClashes) {\n  switch (expr.type) {\n  case \"Identifier\":\n    if (this.strict && this.reservedWordsStrictBind.test(expr.name))\n      this.raiseRecoverable(expr.start, (bindingType ? \"Binding \" : \"Assigning to \") + expr.name + \" in strict mode\")\n    if (checkClashes) {\n      if (has(checkClashes, expr.name))\n        this.raiseRecoverable(expr.start, \"Argument name clash\")\n      checkClashes[expr.name] = true\n    }\n    if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) this.declareName(expr.name, bindingType, expr.start)\n    break\n\n  case \"MemberExpression\":\n    if (bindingType) this.raiseRecoverable(expr.start, \"Binding member expression\")\n    break\n\n  case \"ObjectPattern\":\n    for (let prop of expr.properties)\n      this.checkLVal(prop, bindingType, checkClashes)\n    break\n\n  case \"Property\":\n    // AssignmentProperty has type === \"Property\"\n    this.checkLVal(expr.value, bindingType, checkClashes)\n    break\n\n  case \"ArrayPattern\":\n    for (let elem of expr.elements) {\n      if (elem) this.checkLVal(elem, bindingType, checkClashes)\n    }\n    break\n\n  case \"AssignmentPattern\":\n    this.checkLVal(expr.left, bindingType, checkClashes)\n    break\n\n  case \"RestElement\":\n    this.checkLVal(expr.argument, bindingType, checkClashes)\n    break\n\n  case \"ParenthesizedExpression\":\n    this.checkLVal(expr.expression, bindingType, checkClashes)\n    break\n\n  default:\n    this.raise(expr.start, (bindingType ? \"Binding\" : \"Assigning to\") + \" rvalue\")\n  }\n}\n","// A recursive descent parser operates by defining functions for all\n// syntactic elements, and recursively calling those, each function\n// advancing the input stream and returning an AST node. Precedence\n// of constructs (for example, the fact that `!x[1]` means `!(x[1])`\n// instead of `(!x)[1]` is handled by the fact that the parser\n// function that parses unary prefix operators is called first, and\n// in turn calls the function that parses `[]` subscripts — that\n// way, it'll receive the node for `x[1]` already parsed, and wraps\n// *that* in the unary operator node.\n//\n// Acorn uses an [operator precedence parser][opp] to handle binary\n// operator precedence, because it is much more compact than using\n// the technique outlined above, which uses different, nesting\n// functions to specify precedence, for all of the ten binary\n// precedence levels that JavaScript defines.\n//\n// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser\n\nimport {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {DestructuringErrors} from \"./parseutil\"\nimport {lineBreak} from \"./whitespace\"\nimport {functionFlags, SCOPE_ARROW, SCOPE_SUPER, SCOPE_DIRECT_SUPER, BIND_OUTSIDE, BIND_VAR} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\n// Check if property name clashes with already added.\n// Object/class getters and setters are not allowed to clash —\n// either with each other or with an init property — and in\n// strict mode, init properties are also not allowed to be repeated.\n\npp.checkPropClash = function(prop, propHash, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 9 && prop.type === \"SpreadElement\")\n    return\n  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))\n    return\n  let {key} = prop, name\n  switch (key.type) {\n  case \"Identifier\": name = key.name; break\n  case \"Literal\": name = String(key.value); break\n  default: return\n  }\n  let {kind} = prop\n  if (this.options.ecmaVersion >= 6) {\n    if (name === \"__proto__\" && kind === \"init\") {\n      if (propHash.proto) {\n        if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) refDestructuringErrors.doubleProto = key.start\n        // Backwards-compat kludge. Can be removed in version 6.0\n        else this.raiseRecoverable(key.start, \"Redefinition of __proto__ property\")\n      }\n      propHash.proto = true\n    }\n    return\n  }\n  name = \"$\" + name\n  let other = propHash[name]\n  if (other) {\n    let redefinition\n    if (kind === \"init\") {\n      redefinition = this.strict && other.init || other.get || other.set\n    } else {\n      redefinition = other.init || other[kind]\n    }\n    if (redefinition)\n      this.raiseRecoverable(key.start, \"Redefinition of property\")\n  } else {\n    other = propHash[name] = {\n      init: false,\n      get: false,\n      set: false\n    }\n  }\n  other[kind] = true\n}\n\n// ### Expression parsing\n\n// These nest, from the most general expression type at the top to\n// 'atomic', nondivisible expression types at the bottom. Most of\n// the functions will simply let the function(s) below them parse,\n// and, *if* the syntactic construct they handle is present, wrap\n// the AST node that the inner parser gave them in another node.\n\n// Parse a full expression. The optional arguments are used to\n// forbid the `in` operator (in for loops initalization expressions)\n// and provide reference for storing '=' operator inside shorthand\n// property assignment in contexts where both object expression\n// and object pattern might appear (so it's possible to raise\n// delayed syntax error at correct position).\n\npp.parseExpression = function(noIn, refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseMaybeAssign(noIn, refDestructuringErrors)\n  if (this.type === tt.comma) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.expressions = [expr]\n    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors))\n    return this.finishNode(node, \"SequenceExpression\")\n  }\n  return expr\n}\n\n// Parse an assignment expression. This includes applications of\n// operators like `+=`.\n\npp.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {\n  if (this.isContextual(\"yield\")) {\n    if (this.inGenerator) return this.parseYield(noIn)\n    // The tokenizer will assume an expression is allowed after\n    // `yield`, but this isn't that kind of yield\n    else this.exprAllowed = false\n  }\n\n  let ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldShorthandAssign = -1\n  if (refDestructuringErrors) {\n    oldParenAssign = refDestructuringErrors.parenthesizedAssign\n    oldTrailingComma = refDestructuringErrors.trailingComma\n    oldShorthandAssign = refDestructuringErrors.shorthandAssign\n    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.shorthandAssign = -1\n  } else {\n    refDestructuringErrors = new DestructuringErrors\n    ownDestructuringErrors = true\n  }\n\n  let startPos = this.start, startLoc = this.startLoc\n  if (this.type === tt.parenL || this.type === tt.name)\n    this.potentialArrowAt = this.start\n  let left = this.parseMaybeConditional(noIn, refDestructuringErrors)\n  if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc)\n  if (this.type.isAssign) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.operator = this.value\n    node.left = this.type === tt.eq ? this.toAssignable(left, false, refDestructuringErrors) : left\n    if (!ownDestructuringErrors) DestructuringErrors.call(refDestructuringErrors)\n    refDestructuringErrors.shorthandAssign = -1 // reset because shorthand default was used correctly\n    this.checkLVal(left)\n    this.next()\n    node.right = this.parseMaybeAssign(noIn)\n    return this.finishNode(node, \"AssignmentExpression\")\n  } else {\n    if (ownDestructuringErrors) this.checkExpressionErrors(refDestructuringErrors, true)\n  }\n  if (oldParenAssign > -1) refDestructuringErrors.parenthesizedAssign = oldParenAssign\n  if (oldTrailingComma > -1) refDestructuringErrors.trailingComma = oldTrailingComma\n  if (oldShorthandAssign > -1) refDestructuringErrors.shorthandAssign = oldShorthandAssign\n  return left\n}\n\n// Parse a ternary conditional (`?:`) operator.\n\npp.parseMaybeConditional = function(noIn, refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseExprOps(noIn, refDestructuringErrors)\n  if (this.checkExpressionErrors(refDestructuringErrors)) return expr\n  if (this.eat(tt.question)) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.test = expr\n    node.consequent = this.parseMaybeAssign()\n    this.expect(tt.colon)\n    node.alternate = this.parseMaybeAssign(noIn)\n    return this.finishNode(node, \"ConditionalExpression\")\n  }\n  return expr\n}\n\n// Start the precedence parser.\n\npp.parseExprOps = function(noIn, refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseMaybeUnary(refDestructuringErrors, false)\n  if (this.checkExpressionErrors(refDestructuringErrors)) return expr\n  return expr.start === startPos && expr.type === \"ArrowFunctionExpression\" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)\n}\n\n// Parse binary operators with the operator precedence parsing\n// algorithm. `left` is the left-hand side of the operator.\n// `minPrec` provides context that allows the function to stop and\n// defer further parser to one of its callers when it encounters an\n// operator that has a lower precedence than the set it is parsing.\n\npp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {\n  let prec = this.type.binop\n  if (prec != null && (!noIn || this.type !== tt._in)) {\n    if (prec > minPrec) {\n      let logical = this.type === tt.logicalOR || this.type === tt.logicalAND\n      let op = this.value\n      this.next()\n      let startPos = this.start, startLoc = this.startLoc\n      let right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn)\n      let node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical)\n      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)\n    }\n  }\n  return left\n}\n\npp.buildBinary = function(startPos, startLoc, left, right, op, logical) {\n  let node = this.startNodeAt(startPos, startLoc)\n  node.left = left\n  node.operator = op\n  node.right = right\n  return this.finishNode(node, logical ? \"LogicalExpression\" : \"BinaryExpression\")\n}\n\n// Parse unary operators, both prefix and postfix.\n\npp.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {\n  let startPos = this.start, startLoc = this.startLoc, expr\n  if (this.isContextual(\"await\") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {\n    expr = this.parseAwait()\n    sawUnary = true\n  } else if (this.type.prefix) {\n    let node = this.startNode(), update = this.type === tt.incDec\n    node.operator = this.value\n    node.prefix = true\n    this.next()\n    node.argument = this.parseMaybeUnary(null, true)\n    this.checkExpressionErrors(refDestructuringErrors, true)\n    if (update) this.checkLVal(node.argument)\n    else if (this.strict && node.operator === \"delete\" &&\n             node.argument.type === \"Identifier\")\n      this.raiseRecoverable(node.start, \"Deleting local variable in strict mode\")\n    else sawUnary = true\n    expr = this.finishNode(node, update ? \"UpdateExpression\" : \"UnaryExpression\")\n  } else {\n    expr = this.parseExprSubscripts(refDestructuringErrors)\n    if (this.checkExpressionErrors(refDestructuringErrors)) return expr\n    while (this.type.postfix && !this.canInsertSemicolon()) {\n      let node = this.startNodeAt(startPos, startLoc)\n      node.operator = this.value\n      node.prefix = false\n      node.argument = expr\n      this.checkLVal(expr)\n      this.next()\n      expr = this.finishNode(node, \"UpdateExpression\")\n    }\n  }\n\n  if (!sawUnary && this.eat(tt.starstar))\n    return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), \"**\", false)\n  else\n    return expr\n}\n\n// Parse call, dot, and `[]`-subscript expressions.\n\npp.parseExprSubscripts = function(refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseExprAtom(refDestructuringErrors)\n  let skipArrowSubscripts = expr.type === \"ArrowFunctionExpression\" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== \")\"\n  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) return expr\n  let result = this.parseSubscripts(expr, startPos, startLoc)\n  if (refDestructuringErrors && result.type === \"MemberExpression\") {\n    if (refDestructuringErrors.parenthesizedAssign >= result.start) refDestructuringErrors.parenthesizedAssign = -1\n    if (refDestructuringErrors.parenthesizedBind >= result.start) refDestructuringErrors.parenthesizedBind = -1\n  }\n  return result\n}\n\npp.parseSubscripts = function(base, startPos, startLoc, noCalls) {\n  let maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === \"Identifier\" && base.name === \"async\" &&\n      this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === \"async\"\n  while (true) {\n    let element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow)\n    if (element === base || element.type === \"ArrowFunctionExpression\") return element\n    base = element\n  }\n}\n\npp.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {\n  let computed = this.eat(tt.bracketL)\n  if (computed || this.eat(tt.dot)) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.object = base\n    node.property = computed ? this.parseExpression() : this.parseIdent(true)\n    node.computed = !!computed\n    if (computed) this.expect(tt.bracketR)\n    base = this.finishNode(node, \"MemberExpression\")\n  } else if (!noCalls && this.eat(tt.parenL)) {\n    let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n    this.yieldPos = 0\n    this.awaitPos = 0\n    this.awaitIdentPos = 0\n    let exprList = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors)\n    if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false)\n      this.checkYieldAwaitInDefaultParams()\n      if (this.awaitIdentPos > 0)\n        this.raise(this.awaitIdentPos, \"Cannot use 'await' as identifier inside an async function\")\n      this.yieldPos = oldYieldPos\n      this.awaitPos = oldAwaitPos\n      this.awaitIdentPos = oldAwaitIdentPos\n      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)\n    }\n    this.checkExpressionErrors(refDestructuringErrors, true)\n    this.yieldPos = oldYieldPos || this.yieldPos\n    this.awaitPos = oldAwaitPos || this.awaitPos\n    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos\n    let node = this.startNodeAt(startPos, startLoc)\n    node.callee = base\n    node.arguments = exprList\n    base = this.finishNode(node, \"CallExpression\")\n  } else if (this.type === tt.backQuote) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.tag = base\n    node.quasi = this.parseTemplate({isTagged: true})\n    base = this.finishNode(node, \"TaggedTemplateExpression\")\n  }\n  return base\n}\n\n// Parse an atomic expression — either a single token that is an\n// expression, an expression started by a keyword like `function` or\n// `new`, or an expression wrapped in punctuation like `()`, `[]`,\n// or `{}`.\n\npp.parseExprAtom = function(refDestructuringErrors) {\n  // If a division operator appears in an expression position, the\n  // tokenizer got confused, and we force it to read a regexp instead.\n  if (this.type === tt.slash) this.readRegexp()\n\n  let node, canBeArrow = this.potentialArrowAt === this.start\n  switch (this.type) {\n  case tt._super:\n    if (!this.allowSuper)\n      this.raise(this.start, \"'super' keyword outside a method\")\n    node = this.startNode()\n    this.next()\n    if (this.type === tt.parenL && !this.allowDirectSuper)\n      this.raise(node.start, \"super() call outside constructor of a subclass\")\n    // The `super` keyword can appear at below:\n    // SuperProperty:\n    //     super [ Expression ]\n    //     super . IdentifierName\n    // SuperCall:\n    //     super Arguments\n    if (this.type !== tt.dot && this.type !== tt.bracketL && this.type !== tt.parenL)\n      this.unexpected()\n    return this.finishNode(node, \"Super\")\n\n  case tt._this:\n    node = this.startNode()\n    this.next()\n    return this.finishNode(node, \"ThisExpression\")\n\n  case tt.name:\n    let startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc\n    let id = this.parseIdent(false)\n    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === \"async\" && !this.canInsertSemicolon() && this.eat(tt._function))\n      return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true)\n    if (canBeArrow && !this.canInsertSemicolon()) {\n      if (this.eat(tt.arrow))\n        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false)\n      if (this.options.ecmaVersion >= 8 && id.name === \"async\" && this.type === tt.name && !containsEsc) {\n        id = this.parseIdent(false)\n        if (this.canInsertSemicolon() || !this.eat(tt.arrow))\n          this.unexpected()\n        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)\n      }\n    }\n    return id\n\n  case tt.regexp:\n    let value = this.value\n    node = this.parseLiteral(value.value)\n    node.regex = {pattern: value.pattern, flags: value.flags}\n    return node\n\n  case tt.num: case tt.string:\n    return this.parseLiteral(this.value)\n\n  case tt._null: case tt._true: case tt._false:\n    node = this.startNode()\n    node.value = this.type === tt._null ? null : this.type === tt._true\n    node.raw = this.type.keyword\n    this.next()\n    return this.finishNode(node, \"Literal\")\n\n  case tt.parenL:\n    let start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow)\n    if (refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))\n        refDestructuringErrors.parenthesizedAssign = start\n      if (refDestructuringErrors.parenthesizedBind < 0)\n        refDestructuringErrors.parenthesizedBind = start\n    }\n    return expr\n\n  case tt.bracketL:\n    node = this.startNode()\n    this.next()\n    node.elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors)\n    return this.finishNode(node, \"ArrayExpression\")\n\n  case tt.braceL:\n    return this.parseObj(false, refDestructuringErrors)\n\n  case tt._function:\n    node = this.startNode()\n    this.next()\n    return this.parseFunction(node, 0)\n\n  case tt._class:\n    return this.parseClass(this.startNode(), false)\n\n  case tt._new:\n    return this.parseNew()\n\n  case tt.backQuote:\n    return this.parseTemplate()\n\n  default:\n    this.unexpected()\n  }\n}\n\npp.parseLiteral = function(value) {\n  let node = this.startNode()\n  node.value = value\n  node.raw = this.input.slice(this.start, this.end)\n  this.next()\n  return this.finishNode(node, \"Literal\")\n}\n\npp.parseParenExpression = function() {\n  this.expect(tt.parenL)\n  let val = this.parseExpression()\n  this.expect(tt.parenR)\n  return val\n}\n\npp.parseParenAndDistinguishExpression = function(canBeArrow) {\n  let startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8\n  if (this.options.ecmaVersion >= 6) {\n    this.next()\n\n    let innerStartPos = this.start, innerStartLoc = this.startLoc\n    let exprList = [], first = true, lastIsComma = false\n    let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart\n    this.yieldPos = 0\n    this.awaitPos = 0\n    // Do not save awaitIdentPos to allow checking awaits nested in parameters\n    while (this.type !== tt.parenR) {\n      first ? first = false : this.expect(tt.comma)\n      if (allowTrailingComma && this.afterTrailingComma(tt.parenR, true)) {\n        lastIsComma = true\n        break\n      } else if (this.type === tt.ellipsis) {\n        spreadStart = this.start\n        exprList.push(this.parseParenItem(this.parseRestBinding()))\n        if (this.type === tt.comma) this.raise(this.start, \"Comma is not permitted after the rest element\")\n        break\n      } else {\n        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem))\n      }\n    }\n    let innerEndPos = this.start, innerEndLoc = this.startLoc\n    this.expect(tt.parenR)\n\n    if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false)\n      this.checkYieldAwaitInDefaultParams()\n      this.yieldPos = oldYieldPos\n      this.awaitPos = oldAwaitPos\n      return this.parseParenArrowList(startPos, startLoc, exprList)\n    }\n\n    if (!exprList.length || lastIsComma) this.unexpected(this.lastTokStart)\n    if (spreadStart) this.unexpected(spreadStart)\n    this.checkExpressionErrors(refDestructuringErrors, true)\n    this.yieldPos = oldYieldPos || this.yieldPos\n    this.awaitPos = oldAwaitPos || this.awaitPos\n\n    if (exprList.length > 1) {\n      val = this.startNodeAt(innerStartPos, innerStartLoc)\n      val.expressions = exprList\n      this.finishNodeAt(val, \"SequenceExpression\", innerEndPos, innerEndLoc)\n    } else {\n      val = exprList[0]\n    }\n  } else {\n    val = this.parseParenExpression()\n  }\n\n  if (this.options.preserveParens) {\n    let par = this.startNodeAt(startPos, startLoc)\n    par.expression = val\n    return this.finishNode(par, \"ParenthesizedExpression\")\n  } else {\n    return val\n  }\n}\n\npp.parseParenItem = function(item) {\n  return item\n}\n\npp.parseParenArrowList = function(startPos, startLoc, exprList) {\n  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)\n}\n\n// New's precedence is slightly tricky. It must allow its argument to\n// be a `[]` or dot subscript expression, but not a call — at least,\n// not without wrapping it in parentheses. Thus, it uses the noCalls\n// argument to parseSubscripts to prevent it from consuming the\n// argument list.\n\nconst empty = []\n\npp.parseNew = function() {\n  let node = this.startNode()\n  let meta = this.parseIdent(true)\n  if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {\n    node.meta = meta\n    let containsEsc = this.containsEsc\n    node.property = this.parseIdent(true)\n    if (node.property.name !== \"target\" || containsEsc)\n      this.raiseRecoverable(node.property.start, \"The only valid meta property for new is new.target\")\n    if (!this.inNonArrowFunction())\n      this.raiseRecoverable(node.start, \"new.target can only be used in functions\")\n    return this.finishNode(node, \"MetaProperty\")\n  }\n  let startPos = this.start, startLoc = this.startLoc\n  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true)\n  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false)\n  else node.arguments = empty\n  return this.finishNode(node, \"NewExpression\")\n}\n\n// Parse template expression.\n\npp.parseTemplateElement = function({isTagged}) {\n  let elem = this.startNode()\n  if (this.type === tt.invalidTemplate) {\n    if (!isTagged) {\n      this.raiseRecoverable(this.start, \"Bad escape sequence in untagged template literal\")\n    }\n    elem.value = {\n      raw: this.value,\n      cooked: null\n    }\n  } else {\n    elem.value = {\n      raw: this.input.slice(this.start, this.end).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: this.value\n    }\n  }\n  this.next()\n  elem.tail = this.type === tt.backQuote\n  return this.finishNode(elem, \"TemplateElement\")\n}\n\npp.parseTemplate = function({isTagged = false} = {}) {\n  let node = this.startNode()\n  this.next()\n  node.expressions = []\n  let curElt = this.parseTemplateElement({isTagged})\n  node.quasis = [curElt]\n  while (!curElt.tail) {\n    if (this.type === tt.eof) this.raise(this.pos, \"Unterminated template literal\")\n    this.expect(tt.dollarBraceL)\n    node.expressions.push(this.parseExpression())\n    this.expect(tt.braceR)\n    node.quasis.push(curElt = this.parseTemplateElement({isTagged}))\n  }\n  this.next()\n  return this.finishNode(node, \"TemplateLiteral\")\n}\n\npp.isAsyncProp = function(prop) {\n  return !prop.computed && prop.key.type === \"Identifier\" && prop.key.name === \"async\" &&\n    (this.type === tt.name || this.type === tt.num || this.type === tt.string || this.type === tt.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === tt.star)) &&\n    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n}\n\n// Parse an object literal or binding pattern.\n\npp.parseObj = function(isPattern, refDestructuringErrors) {\n  let node = this.startNode(), first = true, propHash = {}\n  node.properties = []\n  this.next()\n  while (!this.eat(tt.braceR)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (this.afterTrailingComma(tt.braceR)) break\n    } else first = false\n\n    const prop = this.parseProperty(isPattern, refDestructuringErrors)\n    if (!isPattern) this.checkPropClash(prop, propHash, refDestructuringErrors)\n    node.properties.push(prop)\n  }\n  return this.finishNode(node, isPattern ? \"ObjectPattern\" : \"ObjectExpression\")\n}\n\npp.parseProperty = function(isPattern, refDestructuringErrors) {\n  let prop = this.startNode(), isGenerator, isAsync, startPos, startLoc\n  if (this.options.ecmaVersion >= 9 && this.eat(tt.ellipsis)) {\n    if (isPattern) {\n      prop.argument = this.parseIdent(false)\n      if (this.type === tt.comma) {\n        this.raise(this.start, \"Comma is not permitted after the rest element\")\n      }\n      return this.finishNode(prop, \"RestElement\")\n    }\n    // To disallow parenthesized identifier via `this.toAssignable()`.\n    if (this.type === tt.parenL && refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0) {\n        refDestructuringErrors.parenthesizedAssign = this.start\n      }\n      if (refDestructuringErrors.parenthesizedBind < 0) {\n        refDestructuringErrors.parenthesizedBind = this.start\n      }\n    }\n    // Parse argument.\n    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors)\n    // To disallow trailing comma via `this.toAssignable()`.\n    if (this.type === tt.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {\n      refDestructuringErrors.trailingComma = this.start\n    }\n    // Finish\n    return this.finishNode(prop, \"SpreadElement\")\n  }\n  if (this.options.ecmaVersion >= 6) {\n    prop.method = false\n    prop.shorthand = false\n    if (isPattern || refDestructuringErrors) {\n      startPos = this.start\n      startLoc = this.startLoc\n    }\n    if (!isPattern)\n      isGenerator = this.eat(tt.star)\n  }\n  let containsEsc = this.containsEsc\n  this.parsePropertyName(prop)\n  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {\n    isAsync = true\n    isGenerator = this.options.ecmaVersion >= 9 && this.eat(tt.star)\n    this.parsePropertyName(prop, refDestructuringErrors)\n  } else {\n    isAsync = false\n  }\n  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc)\n  return this.finishNode(prop, \"Property\")\n}\n\npp.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {\n  if ((isGenerator || isAsync) && this.type === tt.colon)\n    this.unexpected()\n\n  if (this.eat(tt.colon)) {\n    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors)\n    prop.kind = \"init\"\n  } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {\n    if (isPattern) this.unexpected()\n    prop.kind = \"init\"\n    prop.method = true\n    prop.value = this.parseMethod(isGenerator, isAsync)\n  } else if (!isPattern && !containsEsc &&\n             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === \"Identifier\" &&\n             (prop.key.name === \"get\" || prop.key.name === \"set\") &&\n             (this.type !== tt.comma && this.type !== tt.braceR)) {\n    if (isGenerator || isAsync) this.unexpected()\n    prop.kind = prop.key.name\n    this.parsePropertyName(prop)\n    prop.value = this.parseMethod(false)\n    let paramCount = prop.kind === \"get\" ? 0 : 1\n    if (prop.value.params.length !== paramCount) {\n      let start = prop.value.start\n      if (prop.kind === \"get\")\n        this.raiseRecoverable(start, \"getter should have no params\")\n      else\n        this.raiseRecoverable(start, \"setter should have exactly one param\")\n    } else {\n      if (prop.kind === \"set\" && prop.value.params[0].type === \"RestElement\")\n        this.raiseRecoverable(prop.value.params[0].start, \"Setter cannot use rest params\")\n    }\n  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === \"Identifier\") {\n    if (isGenerator || isAsync) this.unexpected()\n    this.checkUnreserved(prop.key)\n    if (prop.key.name === \"await\" && !this.awaitIdentPos)\n      this.awaitIdentPos = startPos\n    prop.kind = \"init\"\n    if (isPattern) {\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)\n    } else if (this.type === tt.eq && refDestructuringErrors) {\n      if (refDestructuringErrors.shorthandAssign < 0)\n        refDestructuringErrors.shorthandAssign = this.start\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)\n    } else {\n      prop.value = prop.key\n    }\n    prop.shorthand = true\n  } else this.unexpected()\n}\n\npp.parsePropertyName = function(prop) {\n  if (this.options.ecmaVersion >= 6) {\n    if (this.eat(tt.bracketL)) {\n      prop.computed = true\n      prop.key = this.parseMaybeAssign()\n      this.expect(tt.bracketR)\n      return prop.key\n    } else {\n      prop.computed = false\n    }\n  }\n  return prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true)\n}\n\n// Initialize empty function node.\n\npp.initFunction = function(node) {\n  node.id = null\n  if (this.options.ecmaVersion >= 6) node.generator = node.expression = false\n  if (this.options.ecmaVersion >= 8) node.async = false\n}\n\n// Parse object or class method.\n\npp.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {\n  let node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n\n  this.initFunction(node)\n  if (this.options.ecmaVersion >= 6)\n    node.generator = isGenerator\n  if (this.options.ecmaVersion >= 8)\n    node.async = !!isAsync\n\n  this.yieldPos = 0\n  this.awaitPos = 0\n  this.awaitIdentPos = 0\n  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0))\n\n  this.expect(tt.parenL)\n  node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8)\n  this.checkYieldAwaitInDefaultParams()\n  this.parseFunctionBody(node, false, true)\n\n  this.yieldPos = oldYieldPos\n  this.awaitPos = oldAwaitPos\n  this.awaitIdentPos = oldAwaitIdentPos\n  return this.finishNode(node, \"FunctionExpression\")\n}\n\n// Parse arrow function expression with given parameters.\n\npp.parseArrowExpression = function(node, params, isAsync) {\n  let oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n\n  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW)\n  this.initFunction(node)\n  if (this.options.ecmaVersion >= 8) node.async = !!isAsync\n\n  this.yieldPos = 0\n  this.awaitPos = 0\n  this.awaitIdentPos = 0\n\n  node.params = this.toAssignableList(params, true)\n  this.parseFunctionBody(node, true, false)\n\n  this.yieldPos = oldYieldPos\n  this.awaitPos = oldAwaitPos\n  this.awaitIdentPos = oldAwaitIdentPos\n  return this.finishNode(node, \"ArrowFunctionExpression\")\n}\n\n// Parse function body and check parameters.\n\npp.parseFunctionBody = function(node, isArrowFunction, isMethod) {\n  let isExpression = isArrowFunction && this.type !== tt.braceL\n  let oldStrict = this.strict, useStrict = false\n\n  if (isExpression) {\n    node.body = this.parseMaybeAssign()\n    node.expression = true\n    this.checkParams(node, false)\n  } else {\n    let nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params)\n    if (!oldStrict || nonSimple) {\n      useStrict = this.strictDirective(this.end)\n      // If this is a strict mode function, verify that argument names\n      // are not repeated, and it does not try to bind the words `eval`\n      // or `arguments`.\n      if (useStrict && nonSimple)\n        this.raiseRecoverable(node.start, \"Illegal 'use strict' directive in function with non-simple parameter list\")\n    }\n    // Start a new scope with regard to labels and the `inFunction`\n    // flag (restore them to their old value afterwards).\n    let oldLabels = this.labels\n    this.labels = []\n    if (useStrict) this.strict = true\n\n    // Add the params to varDeclaredNames to ensure that an error is thrown\n    // if a let/const declaration in the function clashes with one of the params.\n    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params))\n    node.body = this.parseBlock(false)\n    node.expression = false\n    this.adaptDirectivePrologue(node.body.body)\n    this.labels = oldLabels\n  }\n  this.exitScope()\n\n  // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n  if (this.strict && node.id) this.checkLVal(node.id, BIND_OUTSIDE)\n  this.strict = oldStrict\n}\n\npp.isSimpleParamList = function(params) {\n  for (let param of params)\n    if (param.type !== \"Identifier\") return false\n  return true\n}\n\n// Checks function params for various disallowed patterns such as using \"eval\"\n// or \"arguments\" and duplicate parameters.\n\npp.checkParams = function(node, allowDuplicates) {\n  let nameHash = {}\n  for (let param of node.params)\n    this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash)\n}\n\n// Parses a comma-separated list of expressions, and returns them as\n// an array. `close` is the token type that ends the list, and\n// `allowEmpty` can be turned on to allow subsequent commas with\n// nothing in between them to be parsed as `null` (which is needed\n// for array literals).\n\npp.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {\n  let elts = [], first = true\n  while (!this.eat(close)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (allowTrailingComma && this.afterTrailingComma(close)) break\n    } else first = false\n\n    let elt\n    if (allowEmpty && this.type === tt.comma)\n      elt = null\n    else if (this.type === tt.ellipsis) {\n      elt = this.parseSpread(refDestructuringErrors)\n      if (refDestructuringErrors && this.type === tt.comma && refDestructuringErrors.trailingComma < 0)\n        refDestructuringErrors.trailingComma = this.start\n    } else {\n      elt = this.parseMaybeAssign(false, refDestructuringErrors)\n    }\n    elts.push(elt)\n  }\n  return elts\n}\n\npp.checkUnreserved = function({start, end, name}) {\n  if (this.inGenerator && name === \"yield\")\n    this.raiseRecoverable(start, \"Cannot use 'yield' as identifier inside a generator\")\n  if (this.inAsync && name === \"await\")\n    this.raiseRecoverable(start, \"Cannot use 'await' as identifier inside an async function\")\n  if (this.keywords.test(name))\n    this.raise(start, `Unexpected keyword '${name}'`)\n  if (this.options.ecmaVersion < 6 &&\n    this.input.slice(start, end).indexOf(\"\\\\\") !== -1) return\n  const re = this.strict ? this.reservedWordsStrict : this.reservedWords\n  if (re.test(name)) {\n    if (!this.inAsync && name === \"await\")\n      this.raiseRecoverable(start, \"Cannot use keyword 'await' outside an async function\")\n    this.raiseRecoverable(start, `The keyword '${name}' is reserved`)\n  }\n}\n\n// Parse the next token as an identifier. If `liberal` is true (used\n// when parsing properties), it will also convert keywords into\n// identifiers.\n\npp.parseIdent = function(liberal, isBinding) {\n  let node = this.startNode()\n  if (liberal && this.options.allowReserved === \"never\") liberal = false\n  if (this.type === tt.name) {\n    node.name = this.value\n  } else if (this.type.keyword) {\n    node.name = this.type.keyword\n\n    // To fix https://github.com/acornjs/acorn/issues/575\n    // `class` and `function` keywords push new context into this.context.\n    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.\n    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword\n    if ((node.name === \"class\" || node.name === \"function\") &&\n        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {\n      this.context.pop()\n    }\n  } else {\n    this.unexpected()\n  }\n  this.next()\n  this.finishNode(node, \"Identifier\")\n  if (!liberal) {\n    this.checkUnreserved(node)\n    if (node.name === \"await\" && !this.awaitIdentPos)\n      this.awaitIdentPos = node.start\n  }\n  return node\n}\n\n// Parses yield expression inside generator.\n\npp.parseYield = function(noIn) {\n  if (!this.yieldPos) this.yieldPos = this.start\n\n  let node = this.startNode()\n  this.next()\n  if (this.type === tt.semi || this.canInsertSemicolon() || (this.type !== tt.star && !this.type.startsExpr)) {\n    node.delegate = false\n    node.argument = null\n  } else {\n    node.delegate = this.eat(tt.star)\n    node.argument = this.parseMaybeAssign(noIn)\n  }\n  return this.finishNode(node, \"YieldExpression\")\n}\n\npp.parseAwait = function() {\n  if (!this.awaitPos) this.awaitPos = this.start\n\n  let node = this.startNode()\n  this.next()\n  node.argument = this.parseMaybeUnary(null, true)\n  return this.finishNode(node, \"AwaitExpression\")\n}\n","import {Parser} from \"./state\"\nimport {Position, getLineInfo} from \"./locutil\"\n\nconst pp = Parser.prototype\n\n// This function is used to raise exceptions on parse errors. It\n// takes an offset integer (into the current `input`) to indicate\n// the location of the error, attaches the position to the end\n// of the error message, and then raises a `SyntaxError` with that\n// message.\n\npp.raise = function(pos, message) {\n  let loc = getLineInfo(this.input, pos)\n  message += \" (\" + loc.line + \":\" + loc.column + \")\"\n  let err = new SyntaxError(message)\n  err.pos = pos; err.loc = loc; err.raisedAt = this.pos\n  throw err\n}\n\npp.raiseRecoverable = pp.raise\n\npp.curPosition = function() {\n  if (this.options.locations) {\n    return new Position(this.curLine, this.pos - this.lineStart)\n  }\n}\n","import {Parser} from \"./state\"\nimport {SCOPE_VAR, SCOPE_FUNCTION, SCOPE_TOP, SCOPE_ARROW, SCOPE_SIMPLE_CATCH, BIND_LEXICAL, BIND_SIMPLE_CATCH, BIND_FUNCTION} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\nclass Scope {\n  constructor(flags) {\n    this.flags = flags\n    // A list of var-declared names in the current lexical scope\n    this.var = []\n    // A list of lexically-declared names in the current lexical scope\n    this.lexical = []\n    // A list of lexically-declared FunctionDeclaration names in the current lexical scope\n    this.functions = []\n  }\n}\n\n// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.\n\npp.enterScope = function(flags) {\n  this.scopeStack.push(new Scope(flags))\n}\n\npp.exitScope = function() {\n  this.scopeStack.pop()\n}\n\n// The spec says:\n// > At the top level of a function, or script, function declarations are\n// > treated like var declarations rather than like lexical declarations.\npp.treatFunctionsAsVarInScope = function(scope) {\n  return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)\n}\n\npp.declareName = function(name, bindingType, pos) {\n  let redeclared = false\n  if (bindingType === BIND_LEXICAL) {\n    const scope = this.currentScope()\n    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1\n    scope.lexical.push(name)\n    if (this.inModule && (scope.flags & SCOPE_TOP))\n      delete this.undefinedExports[name]\n  } else if (bindingType === BIND_SIMPLE_CATCH) {\n    const scope = this.currentScope()\n    scope.lexical.push(name)\n  } else if (bindingType === BIND_FUNCTION) {\n    const scope = this.currentScope()\n    if (this.treatFunctionsAsVar)\n      redeclared = scope.lexical.indexOf(name) > -1\n    else\n      redeclared = scope.lexical.indexOf(name) > -1 || scope.var.indexOf(name) > -1\n    scope.functions.push(name)\n  } else {\n    for (let i = this.scopeStack.length - 1; i >= 0; --i) {\n      const scope = this.scopeStack[i]\n      if (scope.lexical.indexOf(name) > -1 && !((scope.flags & SCOPE_SIMPLE_CATCH) && scope.lexical[0] === name) ||\n          !this.treatFunctionsAsVarInScope(scope) && scope.functions.indexOf(name) > -1) {\n        redeclared = true\n        break\n      }\n      scope.var.push(name)\n      if (this.inModule && (scope.flags & SCOPE_TOP))\n        delete this.undefinedExports[name]\n      if (scope.flags & SCOPE_VAR) break\n    }\n  }\n  if (redeclared) this.raiseRecoverable(pos, `Identifier '${name}' has already been declared`)\n}\n\npp.checkLocalExport = function(id) {\n  // scope.functions must be empty as Module code is always strict.\n  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&\n      this.scopeStack[0].var.indexOf(id.name) === -1) {\n    this.undefinedExports[id.name] = id\n  }\n}\n\npp.currentScope = function() {\n  return this.scopeStack[this.scopeStack.length - 1]\n}\n\npp.currentVarScope = function() {\n  for (let i = this.scopeStack.length - 1;; i--) {\n    let scope = this.scopeStack[i]\n    if (scope.flags & SCOPE_VAR) return scope\n  }\n}\n\n// Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\npp.currentThisScope = function() {\n  for (let i = this.scopeStack.length - 1;; i--) {\n    let scope = this.scopeStack[i]\n    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) return scope\n  }\n}\n","import {Parser} from \"./state\"\nimport {SourceLocation} from \"./locutil\"\n\nexport class Node {\n  constructor(parser, pos, loc) {\n    this.type = \"\"\n    this.start = pos\n    this.end = 0\n    if (parser.options.locations)\n      this.loc = new SourceLocation(parser, loc)\n    if (parser.options.directSourceFile)\n      this.sourceFile = parser.options.directSourceFile\n    if (parser.options.ranges)\n      this.range = [pos, 0]\n  }\n}\n\n// Start an AST node, attaching a start offset.\n\nconst pp = Parser.prototype\n\npp.startNode = function() {\n  return new Node(this, this.start, this.startLoc)\n}\n\npp.startNodeAt = function(pos, loc) {\n  return new Node(this, pos, loc)\n}\n\n// Finish an AST node, adding `type` and `end` properties.\n\nfunction finishNodeAt(node, type, pos, loc) {\n  node.type = type\n  node.end = pos\n  if (this.options.locations)\n    node.loc.end = loc\n  if (this.options.ranges)\n    node.range[1] = pos\n  return node\n}\n\npp.finishNode = function(node, type) {\n  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)\n}\n\n// Finish node at given position\n\npp.finishNodeAt = function(node, type, pos, loc) {\n  return finishNodeAt.call(this, node, type, pos, loc)\n}\n","// The algorithm used to determine whether a regexp can appear at a\n// given point in the program is loosely based on sweet.js' approach.\n// See https://github.com/mozilla/sweet.js/wiki/design\n\nimport {Parser} from \"./state\"\nimport {types as tt} from \"./tokentype\"\nimport {lineBreak} from \"./whitespace\"\n\nexport class TokContext {\n  constructor(token, isExpr, preserveSpace, override, generator) {\n    this.token = token\n    this.isExpr = !!isExpr\n    this.preserveSpace = !!preserveSpace\n    this.override = override\n    this.generator = !!generator\n  }\n}\n\nexport const types = {\n  b_stat: new TokContext(\"{\", false),\n  b_expr: new TokContext(\"{\", true),\n  b_tmpl: new TokContext(\"${\", false),\n  p_stat: new TokContext(\"(\", false),\n  p_expr: new TokContext(\"(\", true),\n  q_tmpl: new TokContext(\"`\", true, true, p => p.tryReadTemplateToken()),\n  f_stat: new TokContext(\"function\", false),\n  f_expr: new TokContext(\"function\", true),\n  f_expr_gen: new TokContext(\"function\", true, false, null, true),\n  f_gen: new TokContext(\"function\", false, false, null, true)\n}\n\nconst pp = Parser.prototype\n\npp.initialContext = function() {\n  return [types.b_stat]\n}\n\npp.braceIsBlock = function(prevType) {\n  let parent = this.curContext()\n  if (parent === types.f_expr || parent === types.f_stat)\n    return true\n  if (prevType === tt.colon && (parent === types.b_stat || parent === types.b_expr))\n    return !parent.isExpr\n\n  // The check for `tt.name && exprAllowed` detects whether we are\n  // after a `yield` or `of` construct. See the `updateContext` for\n  // `tt.name`.\n  if (prevType === tt._return || prevType === tt.name && this.exprAllowed)\n    return lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n  if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof || prevType === tt.parenR || prevType === tt.arrow)\n    return true\n  if (prevType === tt.braceL)\n    return parent === types.b_stat\n  if (prevType === tt._var || prevType === tt._const || prevType === tt.name)\n    return false\n  return !this.exprAllowed\n}\n\npp.inGeneratorContext = function() {\n  for (let i = this.context.length - 1; i >= 1; i--) {\n    let context = this.context[i]\n    if (context.token === \"function\")\n      return context.generator\n  }\n  return false\n}\n\npp.updateContext = function(prevType) {\n  let update, type = this.type\n  if (type.keyword && prevType === tt.dot)\n    this.exprAllowed = false\n  else if (update = type.updateContext)\n    update.call(this, prevType)\n  else\n    this.exprAllowed = type.beforeExpr\n}\n\n// Token-specific context update code\n\ntt.parenR.updateContext = tt.braceR.updateContext = function() {\n  if (this.context.length === 1) {\n    this.exprAllowed = true\n    return\n  }\n  let out = this.context.pop()\n  if (out === types.b_stat && this.curContext().token === \"function\") {\n    out = this.context.pop()\n  }\n  this.exprAllowed = !out.isExpr\n}\n\ntt.braceL.updateContext = function(prevType) {\n  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr)\n  this.exprAllowed = true\n}\n\ntt.dollarBraceL.updateContext = function() {\n  this.context.push(types.b_tmpl)\n  this.exprAllowed = true\n}\n\ntt.parenL.updateContext = function(prevType) {\n  let statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while\n  this.context.push(statementParens ? types.p_stat : types.p_expr)\n  this.exprAllowed = true\n}\n\ntt.incDec.updateContext = function() {\n  // tokExprAllowed stays unchanged\n}\n\ntt._function.updateContext = tt._class.updateContext = function(prevType) {\n  if (prevType.beforeExpr && prevType !== tt.semi && prevType !== tt._else &&\n      !(prevType === tt._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&\n      !((prevType === tt.colon || prevType === tt.braceL) && this.curContext() === types.b_stat))\n    this.context.push(types.f_expr)\n  else\n    this.context.push(types.f_stat)\n  this.exprAllowed = false\n}\n\ntt.backQuote.updateContext = function() {\n  if (this.curContext() === types.q_tmpl)\n    this.context.pop()\n  else\n    this.context.push(types.q_tmpl)\n  this.exprAllowed = false\n}\n\ntt.star.updateContext = function(prevType) {\n  if (prevType === tt._function) {\n    let index = this.context.length - 1\n    if (this.context[index] === types.f_expr)\n      this.context[index] = types.f_expr_gen\n    else\n      this.context[index] = types.f_gen\n  }\n  this.exprAllowed = true\n}\n\ntt.name.updateContext = function(prevType) {\n  let allowed = false\n  if (this.options.ecmaVersion >= 6 && prevType !== tt.dot) {\n    if (this.value === \"of\" && !this.exprAllowed ||\n        this.value === \"yield\" && this.inGeneratorContext())\n      allowed = true\n  }\n  this.exprAllowed = allowed\n}\n","import {wordsRegexp} from \"./util.js\"\n\n// This file contains Unicode properties extracted from the ECMAScript\n// specification. The lists are extracted like so:\n// $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)\n\n// #table-binary-unicode-properties\nconst ecma9BinaryProperties = \"ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS\"\nconst unicodeBinaryProperties = {\n  9: ecma9BinaryProperties,\n  10: ecma9BinaryProperties + \" Extended_Pictographic\"\n}\n\n// #table-unicode-general-category-values\nconst unicodeGeneralCategoryValues = \"Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu\"\n\n// #table-unicode-script-values\nconst ecma9ScriptValues = \"Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb\"\nconst unicodeScriptValues = {\n  9: ecma9ScriptValues,\n  10: ecma9ScriptValues + \" Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd\"\n}\n\nconst data = {}\nfunction buildUnicodeData(ecmaVersion) {\n  let d = data[ecmaVersion] = {\n    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + \" \" + unicodeGeneralCategoryValues),\n    nonBinary: {\n      General_Category: wordsRegexp(unicodeGeneralCategoryValues),\n      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])\n    }\n  }\n  d.nonBinary.Script_Extensions = d.nonBinary.Script\n\n  d.nonBinary.gc = d.nonBinary.General_Category\n  d.nonBinary.sc = d.nonBinary.Script\n  d.nonBinary.scx = d.nonBinary.Script_Extensions\n}\nbuildUnicodeData(9)\nbuildUnicodeData(10)\n\nexport default data\n","import {isIdentifierStart, isIdentifierChar} from \"./identifier.js\"\nimport {Parser} from \"./state.js\"\nimport UNICODE_PROPERTY_VALUES from \"./unicode-property-data.js\"\nimport {has} from \"./util.js\"\n\nconst pp = Parser.prototype\n\nexport class RegExpValidationState {\n  constructor(parser) {\n    this.parser = parser\n    this.validFlags = `gim${parser.options.ecmaVersion >= 6 ? \"uy\" : \"\"}${parser.options.ecmaVersion >= 9 ? \"s\" : \"\"}`\n    this.unicodeProperties = UNICODE_PROPERTY_VALUES[parser.options.ecmaVersion >= 10 ? 10 : parser.options.ecmaVersion]\n    this.source = \"\"\n    this.flags = \"\"\n    this.start = 0\n    this.switchU = false\n    this.switchN = false\n    this.pos = 0\n    this.lastIntValue = 0\n    this.lastStringValue = \"\"\n    this.lastAssertionIsQuantifiable = false\n    this.numCapturingParens = 0\n    this.maxBackReference = 0\n    this.groupNames = []\n    this.backReferenceNames = []\n  }\n\n  reset(start, pattern, flags) {\n    const unicode = flags.indexOf(\"u\") !== -1\n    this.start = start | 0\n    this.source = pattern + \"\"\n    this.flags = flags\n    this.switchU = unicode && this.parser.options.ecmaVersion >= 6\n    this.switchN = unicode && this.parser.options.ecmaVersion >= 9\n  }\n\n  raise(message) {\n    this.parser.raiseRecoverable(this.start, `Invalid regular expression: /${this.source}/: ${message}`)\n  }\n\n  // If u flag is given, this returns the code point at the index (it combines a surrogate pair).\n  // Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).\n  at(i) {\n    const s = this.source\n    const l = s.length\n    if (i >= l) {\n      return -1\n    }\n    const c = s.charCodeAt(i)\n    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n      return c\n    }\n    return (c << 10) + s.charCodeAt(i + 1) - 0x35FDC00\n  }\n\n  nextIndex(i) {\n    const s = this.source\n    const l = s.length\n    if (i >= l) {\n      return l\n    }\n    const c = s.charCodeAt(i)\n    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n      return i + 1\n    }\n    return i + 2\n  }\n\n  current() {\n    return this.at(this.pos)\n  }\n\n  lookahead() {\n    return this.at(this.nextIndex(this.pos))\n  }\n\n  advance() {\n    this.pos = this.nextIndex(this.pos)\n  }\n\n  eat(ch) {\n    if (this.current() === ch) {\n      this.advance()\n      return true\n    }\n    return false\n  }\n}\n\nfunction codePointToString(ch) {\n  if (ch <= 0xFFFF) return String.fromCharCode(ch)\n  ch -= 0x10000\n  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)\n}\n\n/**\n * Validate the flags part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp.validateRegExpFlags = function(state) {\n  const validFlags = state.validFlags\n  const flags = state.flags\n\n  for (let i = 0; i < flags.length; i++) {\n    const flag = flags.charAt(i)\n    if (validFlags.indexOf(flag) === -1) {\n      this.raise(state.start, \"Invalid regular expression flag\")\n    }\n    if (flags.indexOf(flag, i + 1) > -1) {\n      this.raise(state.start, \"Duplicate regular expression flag\")\n    }\n  }\n}\n\n/**\n * Validate the pattern part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp.validateRegExpPattern = function(state) {\n  this.regexp_pattern(state)\n\n  // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of\n  // parsing contains a |GroupName|, reparse with the goal symbol\n  // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*\n  // exception if _P_ did not conform to the grammar, if any elements of _P_\n  // were not matched by the parse, or if any Early Error conditions exist.\n  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {\n    state.switchN = true\n    this.regexp_pattern(state)\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern\npp.regexp_pattern = function(state) {\n  state.pos = 0\n  state.lastIntValue = 0\n  state.lastStringValue = \"\"\n  state.lastAssertionIsQuantifiable = false\n  state.numCapturingParens = 0\n  state.maxBackReference = 0\n  state.groupNames.length = 0\n  state.backReferenceNames.length = 0\n\n  this.regexp_disjunction(state)\n\n  if (state.pos !== state.source.length) {\n    // Make the same messages as V8.\n    if (state.eat(0x29 /* ) */)) {\n      state.raise(\"Unmatched ')'\")\n    }\n    if (state.eat(0x5D /* [ */) || state.eat(0x7D /* } */)) {\n      state.raise(\"Lone quantifier brackets\")\n    }\n  }\n  if (state.maxBackReference > state.numCapturingParens) {\n    state.raise(\"Invalid escape\")\n  }\n  for (const name of state.backReferenceNames) {\n    if (state.groupNames.indexOf(name) === -1) {\n      state.raise(\"Invalid named capture referenced\")\n    }\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction\npp.regexp_disjunction = function(state) {\n  this.regexp_alternative(state)\n  while (state.eat(0x7C /* | */)) {\n    this.regexp_alternative(state)\n  }\n\n  // Make the same message as V8.\n  if (this.regexp_eatQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\")\n  }\n  if (state.eat(0x7B /* { */)) {\n    state.raise(\"Lone quantifier brackets\")\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative\npp.regexp_alternative = function(state) {\n  while (state.pos < state.source.length && this.regexp_eatTerm(state))\n    ;\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term\npp.regexp_eatTerm = function(state) {\n  if (this.regexp_eatAssertion(state)) {\n    // Handle `QuantifiableAssertion Quantifier` alternative.\n    // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion\n    // is a QuantifiableAssertion.\n    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {\n      // Make the same message as V8.\n      if (state.switchU) {\n        state.raise(\"Invalid quantifier\")\n      }\n    }\n    return true\n  }\n\n  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {\n    this.regexp_eatQuantifier(state)\n    return true\n  }\n\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion\npp.regexp_eatAssertion = function(state) {\n  const start = state.pos\n  state.lastAssertionIsQuantifiable = false\n\n  // ^, $\n  if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {\n    return true\n  }\n\n  // \\b \\B\n  if (state.eat(0x5C /* \\ */)) {\n    if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {\n      return true\n    }\n    state.pos = start\n  }\n\n  // Lookahead / Lookbehind\n  if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {\n    let lookbehind = false\n    if (this.options.ecmaVersion >= 9) {\n      lookbehind = state.eat(0x3C /* < */)\n    }\n    if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {\n      this.regexp_disjunction(state)\n      if (!state.eat(0x29 /* ) */)) {\n        state.raise(\"Unterminated group\")\n      }\n      state.lastAssertionIsQuantifiable = !lookbehind\n      return true\n    }\n  }\n\n  state.pos = start\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier\npp.regexp_eatQuantifier = function(state, noError = false) {\n  if (this.regexp_eatQuantifierPrefix(state, noError)) {\n    state.eat(0x3F /* ? */)\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix\npp.regexp_eatQuantifierPrefix = function(state, noError) {\n  return (\n    state.eat(0x2A /* * */) ||\n    state.eat(0x2B /* + */) ||\n    state.eat(0x3F /* ? */) ||\n    this.regexp_eatBracedQuantifier(state, noError)\n  )\n}\npp.regexp_eatBracedQuantifier = function(state, noError) {\n  const start = state.pos\n  if (state.eat(0x7B /* { */)) {\n    let min = 0, max = -1\n    if (this.regexp_eatDecimalDigits(state)) {\n      min = state.lastIntValue\n      if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {\n        max = state.lastIntValue\n      }\n      if (state.eat(0x7D /* } */)) {\n        // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term\n        if (max !== -1 && max < min && !noError) {\n          state.raise(\"numbers out of order in {} quantifier\")\n        }\n        return true\n      }\n    }\n    if (state.switchU && !noError) {\n      state.raise(\"Incomplete quantifier\")\n    }\n    state.pos = start\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom\npp.regexp_eatAtom = function(state) {\n  return (\n    this.regexp_eatPatternCharacters(state) ||\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state)\n  )\n}\npp.regexp_eatReverseSolidusAtomEscape = function(state) {\n  const start = state.pos\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatAtomEscape(state)) {\n      return true\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatUncapturingGroup = function(state) {\n  const start = state.pos\n  if (state.eat(0x28 /* ( */)) {\n    if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {\n      this.regexp_disjunction(state)\n      if (state.eat(0x29 /* ) */)) {\n        return true\n      }\n      state.raise(\"Unterminated group\")\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatCapturingGroup = function(state) {\n  if (state.eat(0x28 /* ( */)) {\n    if (this.options.ecmaVersion >= 9) {\n      this.regexp_groupSpecifier(state)\n    } else if (state.current() === 0x3F /* ? */) {\n      state.raise(\"Invalid group\")\n    }\n    this.regexp_disjunction(state)\n    if (state.eat(0x29 /* ) */)) {\n      state.numCapturingParens += 1\n      return true\n    }\n    state.raise(\"Unterminated group\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom\npp.regexp_eatExtendedAtom = function(state) {\n  return (\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state) ||\n    this.regexp_eatInvalidBracedQuantifier(state) ||\n    this.regexp_eatExtendedPatternCharacter(state)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier\npp.regexp_eatInvalidBracedQuantifier = function(state) {\n  if (this.regexp_eatBracedQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter\npp.regexp_eatSyntaxCharacter = function(state) {\n  const ch = state.current()\n  if (isSyntaxCharacter(ch)) {\n    state.lastIntValue = ch\n    state.advance()\n    return true\n  }\n  return false\n}\nfunction isSyntaxCharacter(ch) {\n  return (\n    ch === 0x24 /* $ */ ||\n    ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||\n    ch === 0x2E /* . */ ||\n    ch === 0x3F /* ? */ ||\n    ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||\n    ch >= 0x7B /* { */ && ch <= 0x7D /* } */\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter\n// But eat eager.\npp.regexp_eatPatternCharacters = function(state) {\n  const start = state.pos\n  let ch = 0\n  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {\n    state.advance()\n  }\n  return state.pos !== start\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter\npp.regexp_eatExtendedPatternCharacter = function(state) {\n  const ch = state.current()\n  if (\n    ch !== -1 &&\n    ch !== 0x24 /* $ */ &&\n    !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&\n    ch !== 0x2E /* . */ &&\n    ch !== 0x3F /* ? */ &&\n    ch !== 0x5B /* [ */ &&\n    ch !== 0x5E /* ^ */ &&\n    ch !== 0x7C /* | */\n  ) {\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// GroupSpecifier[U] ::\n//   [empty]\n//   `?` GroupName[?U]\npp.regexp_groupSpecifier = function(state) {\n  if (state.eat(0x3F /* ? */)) {\n    if (this.regexp_eatGroupName(state)) {\n      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {\n        state.raise(\"Duplicate capture group name\")\n      }\n      state.groupNames.push(state.lastStringValue)\n      return\n    }\n    state.raise(\"Invalid group\")\n  }\n}\n\n// GroupName[U] ::\n//   `<` RegExpIdentifierName[?U] `>`\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp.regexp_eatGroupName = function(state) {\n  state.lastStringValue = \"\"\n  if (state.eat(0x3C /* < */)) {\n    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {\n      return true\n    }\n    state.raise(\"Invalid capture group name\")\n  }\n  return false\n}\n\n// RegExpIdentifierName[U] ::\n//   RegExpIdentifierStart[?U]\n//   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp.regexp_eatRegExpIdentifierName = function(state) {\n  state.lastStringValue = \"\"\n  if (this.regexp_eatRegExpIdentifierStart(state)) {\n    state.lastStringValue += codePointToString(state.lastIntValue)\n    while (this.regexp_eatRegExpIdentifierPart(state)) {\n      state.lastStringValue += codePointToString(state.lastIntValue)\n    }\n    return true\n  }\n  return false\n}\n\n// RegExpIdentifierStart[U] ::\n//   UnicodeIDStart\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[?U]\npp.regexp_eatRegExpIdentifierStart = function(state) {\n  const start = state.pos\n  let ch = state.current()\n  state.advance()\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {\n    ch = state.lastIntValue\n  }\n  if (isRegExpIdentifierStart(ch)) {\n    state.lastIntValue = ch\n    return true\n  }\n\n  state.pos = start\n  return false\n}\nfunction isRegExpIdentifierStart(ch) {\n  return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */\n}\n\n// RegExpIdentifierPart[U] ::\n//   UnicodeIDContinue\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[?U]\n//   <ZWNJ>\n//   <ZWJ>\npp.regexp_eatRegExpIdentifierPart = function(state) {\n  const start = state.pos\n  let ch = state.current()\n  state.advance()\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {\n    ch = state.lastIntValue\n  }\n  if (isRegExpIdentifierPart(ch)) {\n    state.lastIntValue = ch\n    return true\n  }\n\n  state.pos = start\n  return false\n}\nfunction isRegExpIdentifierPart(ch) {\n  return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape\npp.regexp_eatAtomEscape = function(state) {\n  if (\n    this.regexp_eatBackReference(state) ||\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state) ||\n    (state.switchN && this.regexp_eatKGroupName(state))\n  ) {\n    return true\n  }\n  if (state.switchU) {\n    // Make the same message as V8.\n    if (state.current() === 0x63 /* c */) {\n      state.raise(\"Invalid unicode escape\")\n    }\n    state.raise(\"Invalid escape\")\n  }\n  return false\n}\npp.regexp_eatBackReference = function(state) {\n  const start = state.pos\n  if (this.regexp_eatDecimalEscape(state)) {\n    const n = state.lastIntValue\n    if (state.switchU) {\n      // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape\n      if (n > state.maxBackReference) {\n        state.maxBackReference = n\n      }\n      return true\n    }\n    if (n <= state.numCapturingParens) {\n      return true\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatKGroupName = function(state) {\n  if (state.eat(0x6B /* k */)) {\n    if (this.regexp_eatGroupName(state)) {\n      state.backReferenceNames.push(state.lastStringValue)\n      return true\n    }\n    state.raise(\"Invalid named reference\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape\npp.regexp_eatCharacterEscape = function(state) {\n  return (\n    this.regexp_eatControlEscape(state) ||\n    this.regexp_eatCControlLetter(state) ||\n    this.regexp_eatZero(state) ||\n    this.regexp_eatHexEscapeSequence(state) ||\n    this.regexp_eatRegExpUnicodeEscapeSequence(state) ||\n    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||\n    this.regexp_eatIdentityEscape(state)\n  )\n}\npp.regexp_eatCControlLetter = function(state) {\n  const start = state.pos\n  if (state.eat(0x63 /* c */)) {\n    if (this.regexp_eatControlLetter(state)) {\n      return true\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatZero = function(state) {\n  if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {\n    state.lastIntValue = 0\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape\npp.regexp_eatControlEscape = function(state) {\n  const ch = state.current()\n  if (ch === 0x74 /* t */) {\n    state.lastIntValue = 0x09 /* \\t */\n    state.advance()\n    return true\n  }\n  if (ch === 0x6E /* n */) {\n    state.lastIntValue = 0x0A /* \\n */\n    state.advance()\n    return true\n  }\n  if (ch === 0x76 /* v */) {\n    state.lastIntValue = 0x0B /* \\v */\n    state.advance()\n    return true\n  }\n  if (ch === 0x66 /* f */) {\n    state.lastIntValue = 0x0C /* \\f */\n    state.advance()\n    return true\n  }\n  if (ch === 0x72 /* r */) {\n    state.lastIntValue = 0x0D /* \\r */\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter\npp.regexp_eatControlLetter = function(state) {\n  const ch = state.current()\n  if (isControlLetter(ch)) {\n    state.lastIntValue = ch % 0x20\n    state.advance()\n    return true\n  }\n  return false\n}\nfunction isControlLetter(ch) {\n  return (\n    (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence\npp.regexp_eatRegExpUnicodeEscapeSequence = function(state) {\n  const start = state.pos\n\n  if (state.eat(0x75 /* u */)) {\n    if (this.regexp_eatFixedHexDigits(state, 4)) {\n      const lead = state.lastIntValue\n      if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {\n        const leadSurrogateEnd = state.pos\n        if (state.eat(0x5C /* \\ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {\n          const trail = state.lastIntValue\n          if (trail >= 0xDC00 && trail <= 0xDFFF) {\n            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000\n            return true\n          }\n        }\n        state.pos = leadSurrogateEnd\n        state.lastIntValue = lead\n      }\n      return true\n    }\n    if (\n      state.switchU &&\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatHexDigits(state) &&\n      state.eat(0x7D /* } */) &&\n      isValidUnicode(state.lastIntValue)\n    ) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid unicode escape\")\n    }\n    state.pos = start\n  }\n\n  return false\n}\nfunction isValidUnicode(ch) {\n  return ch >= 0 && ch <= 0x10FFFF\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape\npp.regexp_eatIdentityEscape = function(state) {\n  if (state.switchU) {\n    if (this.regexp_eatSyntaxCharacter(state)) {\n      return true\n    }\n    if (state.eat(0x2F /* / */)) {\n      state.lastIntValue = 0x2F /* / */\n      return true\n    }\n    return false\n  }\n\n  const ch = state.current()\n  if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {\n    state.lastIntValue = ch\n    state.advance()\n    return true\n  }\n\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape\npp.regexp_eatDecimalEscape = function(state) {\n  state.lastIntValue = 0\n  let ch = state.current()\n  if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {\n    do {\n      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */)\n      state.advance()\n    } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape\npp.regexp_eatCharacterClassEscape = function(state) {\n  const ch = state.current()\n\n  if (isCharacterClassEscape(ch)) {\n    state.lastIntValue = -1\n    state.advance()\n    return true\n  }\n\n  if (\n    state.switchU &&\n    this.options.ecmaVersion >= 9 &&\n    (ch === 0x50 /* P */ || ch === 0x70 /* p */)\n  ) {\n    state.lastIntValue = -1\n    state.advance()\n    if (\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatUnicodePropertyValueExpression(state) &&\n      state.eat(0x7D /* } */)\n    ) {\n      return true\n    }\n    state.raise(\"Invalid property name\")\n  }\n\n  return false\n}\nfunction isCharacterClassEscape(ch) {\n  return (\n    ch === 0x64 /* d */ ||\n    ch === 0x44 /* D */ ||\n    ch === 0x73 /* s */ ||\n    ch === 0x53 /* S */ ||\n    ch === 0x77 /* w */ ||\n    ch === 0x57 /* W */\n  )\n}\n\n// UnicodePropertyValueExpression ::\n//   UnicodePropertyName `=` UnicodePropertyValue\n//   LoneUnicodePropertyNameOrValue\npp.regexp_eatUnicodePropertyValueExpression = function(state) {\n  const start = state.pos\n\n  // UnicodePropertyName `=` UnicodePropertyValue\n  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {\n    const name = state.lastStringValue\n    if (this.regexp_eatUnicodePropertyValue(state)) {\n      const value = state.lastStringValue\n      this.regexp_validateUnicodePropertyNameAndValue(state, name, value)\n      return true\n    }\n  }\n  state.pos = start\n\n  // LoneUnicodePropertyNameOrValue\n  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {\n    const nameOrValue = state.lastStringValue\n    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue)\n    return true\n  }\n  return false\n}\npp.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {\n  if (!has(state.unicodeProperties.nonBinary, name))\n    state.raise(\"Invalid property name\")\n  if (!state.unicodeProperties.nonBinary[name].test(value))\n    state.raise(\"Invalid property value\")\n}\npp.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {\n  if (!state.unicodeProperties.binary.test(nameOrValue))\n    state.raise(\"Invalid property name\")\n}\n\n// UnicodePropertyName ::\n//   UnicodePropertyNameCharacters\npp.regexp_eatUnicodePropertyName = function(state) {\n  let ch = 0\n  state.lastStringValue = \"\"\n  while (isUnicodePropertyNameCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch)\n    state.advance()\n  }\n  return state.lastStringValue !== \"\"\n}\nfunction isUnicodePropertyNameCharacter(ch) {\n  return isControlLetter(ch) || ch === 0x5F /* _ */\n}\n\n// UnicodePropertyValue ::\n//   UnicodePropertyValueCharacters\npp.regexp_eatUnicodePropertyValue = function(state) {\n  let ch = 0\n  state.lastStringValue = \"\"\n  while (isUnicodePropertyValueCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch)\n    state.advance()\n  }\n  return state.lastStringValue !== \"\"\n}\nfunction isUnicodePropertyValueCharacter(ch) {\n  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)\n}\n\n// LoneUnicodePropertyNameOrValue ::\n//   UnicodePropertyValueCharacters\npp.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {\n  return this.regexp_eatUnicodePropertyValue(state)\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass\npp.regexp_eatCharacterClass = function(state) {\n  if (state.eat(0x5B /* [ */)) {\n    state.eat(0x5E /* ^ */)\n    this.regexp_classRanges(state)\n    if (state.eat(0x5D /* [ */)) {\n      return true\n    }\n    // Unreachable since it threw \"unterminated regular expression\" error before.\n    state.raise(\"Unterminated character class\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash\npp.regexp_classRanges = function(state) {\n  while (this.regexp_eatClassAtom(state)) {\n    const left = state.lastIntValue\n    if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {\n      const right = state.lastIntValue\n      if (state.switchU && (left === -1 || right === -1)) {\n        state.raise(\"Invalid character class\")\n      }\n      if (left !== -1 && right !== -1 && left > right) {\n        state.raise(\"Range out of order in character class\")\n      }\n    }\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash\npp.regexp_eatClassAtom = function(state) {\n  const start = state.pos\n\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatClassEscape(state)) {\n      return true\n    }\n    if (state.switchU) {\n      // Make the same message as V8.\n      const ch = state.current()\n      if (ch === 0x63 /* c */ || isOctalDigit(ch)) {\n        state.raise(\"Invalid class escape\")\n      }\n      state.raise(\"Invalid escape\")\n    }\n    state.pos = start\n  }\n\n  const ch = state.current()\n  if (ch !== 0x5D /* [ */) {\n    state.lastIntValue = ch\n    state.advance()\n    return true\n  }\n\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape\npp.regexp_eatClassEscape = function(state) {\n  const start = state.pos\n\n  if (state.eat(0x62 /* b */)) {\n    state.lastIntValue = 0x08 /* <BS> */\n    return true\n  }\n\n  if (state.switchU && state.eat(0x2D /* - */)) {\n    state.lastIntValue = 0x2D /* - */\n    return true\n  }\n\n  if (!state.switchU && state.eat(0x63 /* c */)) {\n    if (this.regexp_eatClassControlLetter(state)) {\n      return true\n    }\n    state.pos = start\n  }\n\n  return (\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter\npp.regexp_eatClassControlLetter = function(state) {\n  const ch = state.current()\n  if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {\n    state.lastIntValue = ch % 0x20\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp.regexp_eatHexEscapeSequence = function(state) {\n  const start = state.pos\n  if (state.eat(0x78 /* x */)) {\n    if (this.regexp_eatFixedHexDigits(state, 2)) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid escape\")\n    }\n    state.pos = start\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits\npp.regexp_eatDecimalDigits = function(state) {\n  const start = state.pos\n  let ch = 0\n  state.lastIntValue = 0\n  while (isDecimalDigit(ch = state.current())) {\n    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */)\n    state.advance()\n  }\n  return state.pos !== start\n}\nfunction isDecimalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits\npp.regexp_eatHexDigits = function(state) {\n  const start = state.pos\n  let ch = 0\n  state.lastIntValue = 0\n  while (isHexDigit(ch = state.current())) {\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch)\n    state.advance()\n  }\n  return state.pos !== start\n}\nfunction isHexDigit(ch) {\n  return (\n    (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||\n    (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)\n  )\n}\nfunction hexToInt(ch) {\n  if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {\n    return 10 + (ch - 0x41 /* A */)\n  }\n  if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {\n    return 10 + (ch - 0x61 /* a */)\n  }\n  return ch - 0x30 /* 0 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence\n// Allows only 0-377(octal) i.e. 0-255(decimal).\npp.regexp_eatLegacyOctalEscapeSequence = function(state) {\n  if (this.regexp_eatOctalDigit(state)) {\n    const n1 = state.lastIntValue\n    if (this.regexp_eatOctalDigit(state)) {\n      const n2 = state.lastIntValue\n      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {\n        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue\n      } else {\n        state.lastIntValue = n1 * 8 + n2\n      }\n    } else {\n      state.lastIntValue = n1\n    }\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit\npp.regexp_eatOctalDigit = function(state) {\n  const ch = state.current()\n  if (isOctalDigit(ch)) {\n    state.lastIntValue = ch - 0x30 /* 0 */\n    state.advance()\n    return true\n  }\n  state.lastIntValue = 0\n  return false\n}\nfunction isOctalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit\n// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp.regexp_eatFixedHexDigits = function(state, length) {\n  const start = state.pos\n  state.lastIntValue = 0\n  for (let i = 0; i < length; ++i) {\n    const ch = state.current()\n    if (!isHexDigit(ch)) {\n      state.pos = start\n      return false\n    }\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch)\n    state.advance()\n  }\n  return true\n}\n","import {isIdentifierStart, isIdentifierChar} from \"./identifier\"\nimport {types as tt, keywords as keywordTypes} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {SourceLocation} from \"./locutil\"\nimport {RegExpValidationState} from \"./regexp\"\nimport {lineBreak, lineBreakG, isNewLine, nonASCIIwhitespace} from \"./whitespace\"\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nexport class Token {\n  constructor(p) {\n    this.type = p.type\n    this.value = p.value\n    this.start = p.start\n    this.end = p.end\n    if (p.options.locations)\n      this.loc = new SourceLocation(p, p.startLoc, p.endLoc)\n    if (p.options.ranges)\n      this.range = [p.start, p.end]\n  }\n}\n\n// ## Tokenizer\n\nconst pp = Parser.prototype\n\n// Move to the next token\n\npp.next = function() {\n  if (this.options.onToken)\n    this.options.onToken(new Token(this))\n\n  this.lastTokEnd = this.end\n  this.lastTokStart = this.start\n  this.lastTokEndLoc = this.endLoc\n  this.lastTokStartLoc = this.startLoc\n  this.nextToken()\n}\n\npp.getToken = function() {\n  this.next()\n  return new Token(this)\n}\n\n// If we're in an ES6 environment, make parsers iterable\nif (typeof Symbol !== \"undefined\")\n  pp[Symbol.iterator] = function() {\n    return {\n      next: () => {\n        let token = this.getToken()\n        return {\n          done: token.type === tt.eof,\n          value: token\n        }\n      }\n    }\n  }\n\n// Toggle strict mode. Re-reads the next number or string to please\n// pedantic tests (`\"use strict\"; 010;` should fail).\n\npp.curContext = function() {\n  return this.context[this.context.length - 1]\n}\n\n// Read a single token, updating the parser object's token-related\n// properties.\n\npp.nextToken = function() {\n  let curContext = this.curContext()\n  if (!curContext || !curContext.preserveSpace) this.skipSpace()\n\n  this.start = this.pos\n  if (this.options.locations) this.startLoc = this.curPosition()\n  if (this.pos >= this.input.length) return this.finishToken(tt.eof)\n\n  if (curContext.override) return curContext.override(this)\n  else this.readToken(this.fullCharCodeAtPos())\n}\n\npp.readToken = function(code) {\n  // Identifier or keyword. '\\uXXXX' sequences are allowed in\n  // identifiers, so '\\' also dispatches to that.\n  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\\' */)\n    return this.readWord()\n\n  return this.getTokenFromCode(code)\n}\n\npp.fullCharCodeAtPos = function() {\n  let code = this.input.charCodeAt(this.pos)\n  if (code <= 0xd7ff || code >= 0xe000) return code\n  let next = this.input.charCodeAt(this.pos + 1)\n  return (code << 10) + next - 0x35fdc00\n}\n\npp.skipBlockComment = function() {\n  let startLoc = this.options.onComment && this.curPosition()\n  let start = this.pos, end = this.input.indexOf(\"*/\", this.pos += 2)\n  if (end === -1) this.raise(this.pos - 2, \"Unterminated comment\")\n  this.pos = end + 2\n  if (this.options.locations) {\n    lineBreakG.lastIndex = start\n    let match\n    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {\n      ++this.curLine\n      this.lineStart = match.index + match[0].length\n    }\n  }\n  if (this.options.onComment)\n    this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,\n                           startLoc, this.curPosition())\n}\n\npp.skipLineComment = function(startSkip) {\n  let start = this.pos\n  let startLoc = this.options.onComment && this.curPosition()\n  let ch = this.input.charCodeAt(this.pos += startSkip)\n  while (this.pos < this.input.length && !isNewLine(ch)) {\n    ch = this.input.charCodeAt(++this.pos)\n  }\n  if (this.options.onComment)\n    this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,\n                           startLoc, this.curPosition())\n}\n\n// Called at the start of the parse and after every token. Skips\n// whitespace and comments, and.\n\npp.skipSpace = function() {\n  loop: while (this.pos < this.input.length) {\n    let ch = this.input.charCodeAt(this.pos)\n    switch (ch) {\n    case 32: case 160: // ' '\n      ++this.pos\n      break\n    case 13:\n      if (this.input.charCodeAt(this.pos + 1) === 10) {\n        ++this.pos\n      }\n    case 10: case 8232: case 8233:\n      ++this.pos\n      if (this.options.locations) {\n        ++this.curLine\n        this.lineStart = this.pos\n      }\n      break\n    case 47: // '/'\n      switch (this.input.charCodeAt(this.pos + 1)) {\n      case 42: // '*'\n        this.skipBlockComment()\n        break\n      case 47:\n        this.skipLineComment(2)\n        break\n      default:\n        break loop\n      }\n      break\n    default:\n      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {\n        ++this.pos\n      } else {\n        break loop\n      }\n    }\n  }\n}\n\n// Called at the end of every token. Sets `end`, `val`, and\n// maintains `context` and `exprAllowed`, and skips the space after\n// the token, so that the next one's `start` will point at the\n// right position.\n\npp.finishToken = function(type, val) {\n  this.end = this.pos\n  if (this.options.locations) this.endLoc = this.curPosition()\n  let prevType = this.type\n  this.type = type\n  this.value = val\n\n  this.updateContext(prevType)\n}\n\n// ### Token reading\n\n// This is the function that is called to fetch the next token. It\n// is somewhat obscure, because it works in character codes rather\n// than characters, and because operator parsing has been inlined\n// into it.\n//\n// All in the name of speed.\n//\npp.readToken_dot = function() {\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next >= 48 && next <= 57) return this.readNumber(true)\n  let next2 = this.input.charCodeAt(this.pos + 2)\n  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'\n    this.pos += 3\n    return this.finishToken(tt.ellipsis)\n  } else {\n    ++this.pos\n    return this.finishToken(tt.dot)\n  }\n}\n\npp.readToken_slash = function() { // '/'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(tt.slash, 1)\n}\n\npp.readToken_mult_modulo_exp = function(code) { // '%*'\n  let next = this.input.charCodeAt(this.pos + 1)\n  let size = 1\n  let tokentype = code === 42 ? tt.star : tt.modulo\n\n  // exponentiation operator ** and **=\n  if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {\n    ++size\n    tokentype = tt.starstar\n    next = this.input.charCodeAt(this.pos + 2)\n  }\n\n  if (next === 61) return this.finishOp(tt.assign, size + 1)\n  return this.finishOp(tokentype, size)\n}\n\npp.readToken_pipe_amp = function(code) { // '|&'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2)\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1)\n}\n\npp.readToken_caret = function() { // '^'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(tt.bitwiseXOR, 1)\n}\n\npp.readToken_plus_min = function(code) { // '+-'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === code) {\n    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&\n        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {\n      // A `-->` line comment\n      this.skipLineComment(3)\n      this.skipSpace()\n      return this.nextToken()\n    }\n    return this.finishOp(tt.incDec, 2)\n  }\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(tt.plusMin, 1)\n}\n\npp.readToken_lt_gt = function(code) { // '<>'\n  let next = this.input.charCodeAt(this.pos + 1)\n  let size = 1\n  if (next === code) {\n    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2\n    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)\n    return this.finishOp(tt.bitShift, size)\n  }\n  if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&\n      this.input.charCodeAt(this.pos + 3) === 45) {\n    // `<!--`, an XML-style comment that should be interpreted as a line comment\n    this.skipLineComment(4)\n    this.skipSpace()\n    return this.nextToken()\n  }\n  if (next === 61) size = 2\n  return this.finishOp(tt.relational, size)\n}\n\npp.readToken_eq_excl = function(code) { // '=!'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2)\n  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'\n    this.pos += 2\n    return this.finishToken(tt.arrow)\n  }\n  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1)\n}\n\npp.getTokenFromCode = function(code) {\n  switch (code) {\n  // The interpretation of a dot depends on whether it is followed\n  // by a digit or another two dots.\n  case 46: // '.'\n    return this.readToken_dot()\n\n  // Punctuation tokens.\n  case 40: ++this.pos; return this.finishToken(tt.parenL)\n  case 41: ++this.pos; return this.finishToken(tt.parenR)\n  case 59: ++this.pos; return this.finishToken(tt.semi)\n  case 44: ++this.pos; return this.finishToken(tt.comma)\n  case 91: ++this.pos; return this.finishToken(tt.bracketL)\n  case 93: ++this.pos; return this.finishToken(tt.bracketR)\n  case 123: ++this.pos; return this.finishToken(tt.braceL)\n  case 125: ++this.pos; return this.finishToken(tt.braceR)\n  case 58: ++this.pos; return this.finishToken(tt.colon)\n  case 63: ++this.pos; return this.finishToken(tt.question)\n\n  case 96: // '`'\n    if (this.options.ecmaVersion < 6) break\n    ++this.pos\n    return this.finishToken(tt.backQuote)\n\n  case 48: // '0'\n    let next = this.input.charCodeAt(this.pos + 1)\n    if (next === 120 || next === 88) return this.readRadixNumber(16) // '0x', '0X' - hex number\n    if (this.options.ecmaVersion >= 6) {\n      if (next === 111 || next === 79) return this.readRadixNumber(8) // '0o', '0O' - octal number\n      if (next === 98 || next === 66) return this.readRadixNumber(2) // '0b', '0B' - binary number\n    }\n\n  // Anything else beginning with a digit is an integer, octal\n  // number, or float.\n  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9\n    return this.readNumber(false)\n\n  // Quotes produce strings.\n  case 34: case 39: // '\"', \"'\"\n    return this.readString(code)\n\n  // Operators are parsed inline in tiny state machines. '=' (61) is\n  // often referred to. `finishOp` simply skips the amount of\n  // characters it is given as second argument, and returns a token\n  // of the type given by its first argument.\n\n  case 47: // '/'\n    return this.readToken_slash()\n\n  case 37: case 42: // '%*'\n    return this.readToken_mult_modulo_exp(code)\n\n  case 124: case 38: // '|&'\n    return this.readToken_pipe_amp(code)\n\n  case 94: // '^'\n    return this.readToken_caret()\n\n  case 43: case 45: // '+-'\n    return this.readToken_plus_min(code)\n\n  case 60: case 62: // '<>'\n    return this.readToken_lt_gt(code)\n\n  case 61: case 33: // '=!'\n    return this.readToken_eq_excl(code)\n\n  case 126: // '~'\n    return this.finishOp(tt.prefix, 1)\n  }\n\n  this.raise(this.pos, \"Unexpected character '\" + codePointToString(code) + \"'\")\n}\n\npp.finishOp = function(type, size) {\n  let str = this.input.slice(this.pos, this.pos + size)\n  this.pos += size\n  return this.finishToken(type, str)\n}\n\npp.readRegexp = function() {\n  let escaped, inClass, start = this.pos\n  for (;;) {\n    if (this.pos >= this.input.length) this.raise(start, \"Unterminated regular expression\")\n    let ch = this.input.charAt(this.pos)\n    if (lineBreak.test(ch)) this.raise(start, \"Unterminated regular expression\")\n    if (!escaped) {\n      if (ch === \"[\") inClass = true\n      else if (ch === \"]\" && inClass) inClass = false\n      else if (ch === \"/\" && !inClass) break\n      escaped = ch === \"\\\\\"\n    } else escaped = false\n    ++this.pos\n  }\n  let pattern = this.input.slice(start, this.pos)\n  ++this.pos\n  let flagsStart = this.pos\n  let flags = this.readWord1()\n  if (this.containsEsc) this.unexpected(flagsStart)\n\n  // Validate pattern\n  const state = this.regexpState || (this.regexpState = new RegExpValidationState(this))\n  state.reset(start, pattern, flags)\n  this.validateRegExpFlags(state)\n  this.validateRegExpPattern(state)\n\n  // Create Literal#value property value.\n  let value = null\n  try {\n    value = new RegExp(pattern, flags)\n  } catch (e) {\n    // ESTree requires null if it failed to instantiate RegExp object.\n    // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral\n  }\n\n  return this.finishToken(tt.regexp, {pattern, flags, value})\n}\n\n// Read an integer in the given radix. Return null if zero digits\n// were read, the integer value otherwise. When `len` is given, this\n// will return `null` unless the integer has exactly `len` digits.\n\npp.readInt = function(radix, len) {\n  let start = this.pos, total = 0\n  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    let code = this.input.charCodeAt(this.pos), val\n    if (code >= 97) val = code - 97 + 10 // a\n    else if (code >= 65) val = code - 65 + 10 // A\n    else if (code >= 48 && code <= 57) val = code - 48 // 0-9\n    else val = Infinity\n    if (val >= radix) break\n    ++this.pos\n    total = total * radix + val\n  }\n  if (this.pos === start || len != null && this.pos - start !== len) return null\n\n  return total\n}\n\npp.readRadixNumber = function(radix) {\n  this.pos += 2 // 0x\n  let val = this.readInt(radix)\n  if (val == null) this.raise(this.start + 2, \"Expected number in radix \" + radix)\n  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, \"Identifier directly after number\")\n  return this.finishToken(tt.num, val)\n}\n\n// Read an integer, octal integer, or floating-point number.\n\npp.readNumber = function(startsWithDot) {\n  let start = this.pos\n  if (!startsWithDot && this.readInt(10) === null) this.raise(start, \"Invalid number\")\n  let octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48\n  if (octal && this.strict) this.raise(start, \"Invalid number\")\n  if (octal && /[89]/.test(this.input.slice(start, this.pos))) octal = false\n  let next = this.input.charCodeAt(this.pos)\n  if (next === 46 && !octal) { // '.'\n    ++this.pos\n    this.readInt(10)\n    next = this.input.charCodeAt(this.pos)\n  }\n  if ((next === 69 || next === 101) && !octal) { // 'eE'\n    next = this.input.charCodeAt(++this.pos)\n    if (next === 43 || next === 45) ++this.pos // '+-'\n    if (this.readInt(10) === null) this.raise(start, \"Invalid number\")\n  }\n  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, \"Identifier directly after number\")\n\n  let str = this.input.slice(start, this.pos)\n  let val = octal ? parseInt(str, 8) : parseFloat(str)\n  return this.finishToken(tt.num, val)\n}\n\n// Read a string value, interpreting backslash-escapes.\n\npp.readCodePoint = function() {\n  let ch = this.input.charCodeAt(this.pos), code\n\n  if (ch === 123) { // '{'\n    if (this.options.ecmaVersion < 6) this.unexpected()\n    let codePos = ++this.pos\n    code = this.readHexChar(this.input.indexOf(\"}\", this.pos) - this.pos)\n    ++this.pos\n    if (code > 0x10FFFF) this.invalidStringToken(codePos, \"Code point out of bounds\")\n  } else {\n    code = this.readHexChar(4)\n  }\n  return code\n}\n\nfunction codePointToString(code) {\n  // UTF-16 Decoding\n  if (code <= 0xFFFF) return String.fromCharCode(code)\n  code -= 0x10000\n  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)\n}\n\npp.readString = function(quote) {\n  let out = \"\", chunkStart = ++this.pos\n  for (;;) {\n    if (this.pos >= this.input.length) this.raise(this.start, \"Unterminated string constant\")\n    let ch = this.input.charCodeAt(this.pos)\n    if (ch === quote) break\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos)\n      out += this.readEscapedChar(false)\n      chunkStart = this.pos\n    } else {\n      if (isNewLine(ch, this.options.ecmaVersion >= 10)) this.raise(this.start, \"Unterminated string constant\")\n      ++this.pos\n    }\n  }\n  out += this.input.slice(chunkStart, this.pos++)\n  return this.finishToken(tt.string, out)\n}\n\n// Reads template string tokens.\n\nconst INVALID_TEMPLATE_ESCAPE_ERROR = {}\n\npp.tryReadTemplateToken = function() {\n  this.inTemplateElement = true\n  try {\n    this.readTmplToken()\n  } catch (err) {\n    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {\n      this.readInvalidTemplateToken()\n    } else {\n      throw err\n    }\n  }\n\n  this.inTemplateElement = false\n}\n\npp.invalidStringToken = function(position, message) {\n  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {\n    throw INVALID_TEMPLATE_ESCAPE_ERROR\n  } else {\n    this.raise(position, message)\n  }\n}\n\npp.readTmplToken = function() {\n  let out = \"\", chunkStart = this.pos\n  for (;;) {\n    if (this.pos >= this.input.length) this.raise(this.start, \"Unterminated template\")\n    let ch = this.input.charCodeAt(this.pos)\n    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'\n      if (this.pos === this.start && (this.type === tt.template || this.type === tt.invalidTemplate)) {\n        if (ch === 36) {\n          this.pos += 2\n          return this.finishToken(tt.dollarBraceL)\n        } else {\n          ++this.pos\n          return this.finishToken(tt.backQuote)\n        }\n      }\n      out += this.input.slice(chunkStart, this.pos)\n      return this.finishToken(tt.template, out)\n    }\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos)\n      out += this.readEscapedChar(true)\n      chunkStart = this.pos\n    } else if (isNewLine(ch)) {\n      out += this.input.slice(chunkStart, this.pos)\n      ++this.pos\n      switch (ch) {\n      case 13:\n        if (this.input.charCodeAt(this.pos) === 10) ++this.pos\n      case 10:\n        out += \"\\n\"\n        break\n      default:\n        out += String.fromCharCode(ch)\n        break\n      }\n      if (this.options.locations) {\n        ++this.curLine\n        this.lineStart = this.pos\n      }\n      chunkStart = this.pos\n    } else {\n      ++this.pos\n    }\n  }\n}\n\n// Reads a template token to search for the end, without validating any escape sequences\npp.readInvalidTemplateToken = function() {\n  for (; this.pos < this.input.length; this.pos++) {\n    switch (this.input[this.pos]) {\n    case \"\\\\\":\n      ++this.pos\n      break\n\n    case \"$\":\n      if (this.input[this.pos + 1] !== \"{\") {\n        break\n      }\n    // falls through\n\n    case \"`\":\n      return this.finishToken(tt.invalidTemplate, this.input.slice(this.start, this.pos))\n\n    // no default\n    }\n  }\n  this.raise(this.start, \"Unterminated template\")\n}\n\n// Used to read escaped characters\n\npp.readEscapedChar = function(inTemplate) {\n  let ch = this.input.charCodeAt(++this.pos)\n  ++this.pos\n  switch (ch) {\n  case 110: return \"\\n\" // 'n' -> '\\n'\n  case 114: return \"\\r\" // 'r' -> '\\r'\n  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'\n  case 117: return codePointToString(this.readCodePoint()) // 'u'\n  case 116: return \"\\t\" // 't' -> '\\t'\n  case 98: return \"\\b\" // 'b' -> '\\b'\n  case 118: return \"\\u000b\" // 'v' -> '\\u000b'\n  case 102: return \"\\f\" // 'f' -> '\\f'\n  case 13: if (this.input.charCodeAt(this.pos) === 10) ++this.pos // '\\r\\n'\n  case 10: // ' \\n'\n    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine }\n    return \"\"\n  default:\n    if (ch >= 48 && ch <= 55) {\n      let octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0]\n      let octal = parseInt(octalStr, 8)\n      if (octal > 255) {\n        octalStr = octalStr.slice(0, -1)\n        octal = parseInt(octalStr, 8)\n      }\n      this.pos += octalStr.length - 1\n      ch = this.input.charCodeAt(this.pos)\n      if ((octalStr !== \"0\" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {\n        this.invalidStringToken(\n          this.pos - 1 - octalStr.length,\n          inTemplate\n            ? \"Octal literal in template string\"\n            : \"Octal literal in strict mode\"\n        )\n      }\n      return String.fromCharCode(octal)\n    }\n    if (isNewLine(ch)) {\n      // Unicode new line characters after \\ get removed from output in both\n      // template literals and strings\n      return \"\"\n    }\n    return String.fromCharCode(ch)\n  }\n}\n\n// Used to read character escape sequences ('\\x', '\\u', '\\U').\n\npp.readHexChar = function(len) {\n  let codePos = this.pos\n  let n = this.readInt(16, len)\n  if (n === null) this.invalidStringToken(codePos, \"Bad character escape sequence\")\n  return n\n}\n\n// Read an identifier, and return it as a string. Sets `this.containsEsc`\n// to whether the word contained a '\\u' escape.\n//\n// Incrementally adds only escaped chars, adding other chunks as-is\n// as a micro-optimization.\n\npp.readWord1 = function() {\n  this.containsEsc = false\n  let word = \"\", first = true, chunkStart = this.pos\n  let astral = this.options.ecmaVersion >= 6\n  while (this.pos < this.input.length) {\n    let ch = this.fullCharCodeAtPos()\n    if (isIdentifierChar(ch, astral)) {\n      this.pos += ch <= 0xffff ? 1 : 2\n    } else if (ch === 92) { // \"\\\"\n      this.containsEsc = true\n      word += this.input.slice(chunkStart, this.pos)\n      let escStart = this.pos\n      if (this.input.charCodeAt(++this.pos) !== 117) // \"u\"\n        this.invalidStringToken(this.pos, \"Expecting Unicode escape sequence \\\\uXXXX\")\n      ++this.pos\n      let esc = this.readCodePoint()\n      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))\n        this.invalidStringToken(escStart, \"Invalid Unicode escape\")\n      word += codePointToString(esc)\n      chunkStart = this.pos\n    } else {\n      break\n    }\n    first = false\n  }\n  return word + this.input.slice(chunkStart, this.pos)\n}\n\n// Read an identifier or keyword token. Will check for reserved\n// words when necessary.\n\npp.readWord = function() {\n  let word = this.readWord1()\n  let type = tt.name\n  if (this.keywords.test(word)) {\n    if (this.containsEsc) this.raiseRecoverable(this.start, \"Escape sequence in keyword \" + word)\n    type = keywordTypes[word]\n  }\n  return this.finishToken(type, word)\n}\n","// Acorn is a tiny, fast JavaScript parser written in JavaScript.\n//\n// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and\n// various contributors and released under an MIT license.\n//\n// Git repositories for Acorn are available at\n//\n//     http://marijnhaverbeke.nl/git/acorn\n//     https://github.com/acornjs/acorn.git\n//\n// Please use the [github bug tracker][ghbt] to report issues.\n//\n// [ghbt]: https://github.com/acornjs/acorn/issues\n//\n// [walk]: util/walk.js\n\nimport {Parser} from \"./state\"\nimport \"./parseutil\"\nimport \"./statement\"\nimport \"./lval\"\nimport \"./expression\"\nimport \"./location\"\nimport \"./scope\"\n\nexport {Parser} from \"./state\"\nexport {defaultOptions} from \"./options\"\nexport {Position, SourceLocation, getLineInfo} from \"./locutil\"\nexport {Node} from \"./node\"\nexport {TokenType, types as tokTypes, keywords as keywordTypes} from \"./tokentype\"\nexport {TokContext, types as tokContexts} from \"./tokencontext\"\nexport {isIdentifierChar, isIdentifierStart} from \"./identifier\"\nexport {Token} from \"./tokenize\"\nexport {isNewLine, lineBreak, lineBreakG, nonASCIIwhitespace} from \"./whitespace\"\n\nexport const version = \"6.1.1\"\n\n// The main exported interface (under `self.acorn` when in the\n// browser) is a `parse` function that takes a code string and\n// returns an abstract syntax tree as specified by [Mozilla parser\n// API][api].\n//\n// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API\n\nexport function parse(input, options) {\n  return Parser.parse(input, options)\n}\n\n// This function tries to parse a single expression at a given\n// offset in a string. Useful for parsing mixed-language formats\n// that embed JavaScript expressions.\n\nexport function parseExpressionAt(input, pos, options) {\n  return Parser.parseExpressionAt(input, pos, options)\n}\n\n// Acorn is organized as a tokenizer and a recursive-descent parser.\n// The `tokenizer` export provides an interface to the tokenizer.\n\nexport function tokenizer(input, options) {\n  return Parser.tokenizer(input, options)\n}\n"],"names":["const","let","keywords","tt","this","pp","init","label","node","empty","scope","types","UNICODE_PROPERTY_VALUES","codePointToString","ch","keywordTypes"],"mappings":";;;;;;AAAA;;AAEA,AAAOA,IAAM,aAAa,GAAG;EAC3B,CAAC,EAAE,qNAAqN;EACxN,CAAC,EAAE,8CAA8C;EACjD,CAAC,EAAE,MAAM;EACT,MAAM,EAAE,wEAAwE;EAChF,UAAU,EAAE,gBAAgB;EAC7B;;;;AAIDA,IAAM,oBAAoB,GAAG,8KAA6K;;AAE1M,AAAOA,IAAM,QAAQ,GAAG;EACtB,CAAC,EAAE,oBAAoB;EACvB,CAAC,EAAE,oBAAoB,GAAG,0CAA0C;EACrE;;AAED,AAAOA,IAAM,yBAAyB,GAAG,kBAAiB;;;;;;;;;;AAU1DC,IAAI,4BAA4B,GAAG,4tIAA2tI;AAC9vIA,IAAI,uBAAuB,GAAG,sjFAAqjF;;AAEnlFD,IAAM,uBAAuB,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,4BAA4B,GAAG,GAAG,EAAC;AACpFA,IAAM,kBAAkB,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,4BAA4B,GAAG,uBAAuB,GAAG,GAAG,EAAC;;AAEzG,4BAA4B,GAAG,uBAAu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vqCA,IAAM,qBAAqB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,C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"}
\ No newline at end of file
diff --git a/node_modules/acorn-globals/node_modules/acorn/dist/acorn.mjs b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.mjs
new file mode 100644
index 0000000..d047593
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.mjs
@@ -0,0 +1,4961 @@
+// Reserved word lists for various dialects of the language
+
+var reservedWords = {
+  3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
+  5: "class enum extends super const export import",
+  6: "enum",
+  strict: "implements interface let package private protected public static yield",
+  strictBind: "eval arguments"
+};
+
+// And the keywords
+
+var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
+
+var keywords = {
+  5: ecma5AndLessKeywords,
+  "5module": ecma5AndLessKeywords + " export import",
+  6: ecma5AndLessKeywords + " const class extends export import super"
+};
+
+var keywordRelationalOperator = /^in(stanceof)?$/;
+
+// ## Character categories
+
+// Big ugly regular expressions that match characters in the
+// whitespace, identifier, and identifier-start categories. These
+// are only applied when a character is found to actually have a
+// code point above 128.
+// Generated by `bin/generate-identifier-regex.js`.
+var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+
+var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+
+// These are a run-length and offset encoded representation of the
+// >0xffff code points that are a valid part of identifiers. The
+// offset starts at 0x10000, and each pair of numbers represents an
+// offset to the next range, and then a size of the range. They were
+// generated by bin/generate-identifier-regex.js
+
+// eslint-disable-next-line comma-spacing
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,155,22,13,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,0,33,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,0,161,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,754,9486,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541];
+
+// eslint-disable-next-line comma-spacing
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,232,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,792487,239];
+
+// This has a complexity linear to the value of the code. The
+// assumption is that looking up astral identifier characters is
+// rare.
+function isInAstralSet(code, set) {
+  var pos = 0x10000;
+  for (var i = 0; i < set.length; i += 2) {
+    pos += set[i];
+    if (pos > code) { return false }
+    pos += set[i + 1];
+    if (pos >= code) { return true }
+  }
+}
+
+// Test whether a given character code starts an identifier.
+
+function isIdentifierStart(code, astral) {
+  if (code < 65) { return code === 36 }
+  if (code < 91) { return true }
+  if (code < 97) { return code === 95 }
+  if (code < 123) { return true }
+  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
+  if (astral === false) { return false }
+  return isInAstralSet(code, astralIdentifierStartCodes)
+}
+
+// Test whether a given character is part of an identifier.
+
+function isIdentifierChar(code, astral) {
+  if (code < 48) { return code === 36 }
+  if (code < 58) { return true }
+  if (code < 65) { return false }
+  if (code < 91) { return true }
+  if (code < 97) { return code === 95 }
+  if (code < 123) { return true }
+  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
+  if (astral === false) { return false }
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
+}
+
+// ## Token types
+
+// The assignment of fine-grained, information-carrying type objects
+// allows the tokenizer to store the information it has about a
+// token in a way that is very cheap for the parser to look up.
+
+// All token type variables start with an underscore, to make them
+// easy to recognize.
+
+// The `beforeExpr` property is used to disambiguate between regular
+// expressions and divisions. It is set on all token types that can
+// be followed by an expression (thus, a slash after them would be a
+// regular expression).
+//
+// The `startsExpr` property is used to check if the token ends a
+// `yield` expression. It is set on all token types that either can
+// directly start an expression (like a quotation mark) or can
+// continue an expression (like the body of a string).
+//
+// `isLoop` marks a keyword as starting a loop, which is important
+// to know when parsing a label, in order to allow or disallow
+// continue jumps to that label.
+
+var TokenType = function TokenType(label, conf) {
+  if ( conf === void 0 ) conf = {};
+
+  this.label = label;
+  this.keyword = conf.keyword;
+  this.beforeExpr = !!conf.beforeExpr;
+  this.startsExpr = !!conf.startsExpr;
+  this.isLoop = !!conf.isLoop;
+  this.isAssign = !!conf.isAssign;
+  this.prefix = !!conf.prefix;
+  this.postfix = !!conf.postfix;
+  this.binop = conf.binop || null;
+  this.updateContext = null;
+};
+
+function binop(name, prec) {
+  return new TokenType(name, {beforeExpr: true, binop: prec})
+}
+var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};
+
+// Map keyword names to token types.
+
+var keywords$1 = {};
+
+// Succinct definitions of keyword token types
+function kw(name, options) {
+  if ( options === void 0 ) options = {};
+
+  options.keyword = name;
+  return keywords$1[name] = new TokenType(name, options)
+}
+
+var types = {
+  num: new TokenType("num", startsExpr),
+  regexp: new TokenType("regexp", startsExpr),
+  string: new TokenType("string", startsExpr),
+  name: new TokenType("name", startsExpr),
+  eof: new TokenType("eof"),
+
+  // Punctuation token types.
+  bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
+  bracketR: new TokenType("]"),
+  braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
+  braceR: new TokenType("}"),
+  parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
+  parenR: new TokenType(")"),
+  comma: new TokenType(",", beforeExpr),
+  semi: new TokenType(";", beforeExpr),
+  colon: new TokenType(":", beforeExpr),
+  dot: new TokenType("."),
+  question: new TokenType("?", beforeExpr),
+  arrow: new TokenType("=>", beforeExpr),
+  template: new TokenType("template"),
+  invalidTemplate: new TokenType("invalidTemplate"),
+  ellipsis: new TokenType("...", beforeExpr),
+  backQuote: new TokenType("`", startsExpr),
+  dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
+
+  // Operators. These carry several kinds of properties to help the
+  // parser use them properly (the presence of these properties is
+  // what categorizes them as operators).
+  //
+  // `binop`, when present, specifies that this operator is a binary
+  // operator, and will refer to its precedence.
+  //
+  // `prefix` and `postfix` mark the operator as a prefix or postfix
+  // unary operator.
+  //
+  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+  // binary operators with a very low precedence, that should result
+  // in AssignmentExpression nodes.
+
+  eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
+  assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
+  incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+  prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
+  logicalOR: binop("||", 1),
+  logicalAND: binop("&&", 2),
+  bitwiseOR: binop("|", 3),
+  bitwiseXOR: binop("^", 4),
+  bitwiseAND: binop("&", 5),
+  equality: binop("==/!=/===/!==", 6),
+  relational: binop("</>/<=/>=", 7),
+  bitShift: binop("<</>>/>>>", 8),
+  plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
+  modulo: binop("%", 10),
+  star: binop("*", 10),
+  slash: binop("/", 10),
+  starstar: new TokenType("**", {beforeExpr: true}),
+
+  // Keyword token types.
+  _break: kw("break"),
+  _case: kw("case", beforeExpr),
+  _catch: kw("catch"),
+  _continue: kw("continue"),
+  _debugger: kw("debugger"),
+  _default: kw("default", beforeExpr),
+  _do: kw("do", {isLoop: true, beforeExpr: true}),
+  _else: kw("else", beforeExpr),
+  _finally: kw("finally"),
+  _for: kw("for", {isLoop: true}),
+  _function: kw("function", startsExpr),
+  _if: kw("if"),
+  _return: kw("return", beforeExpr),
+  _switch: kw("switch"),
+  _throw: kw("throw", beforeExpr),
+  _try: kw("try"),
+  _var: kw("var"),
+  _const: kw("const"),
+  _while: kw("while", {isLoop: true}),
+  _with: kw("with"),
+  _new: kw("new", {beforeExpr: true, startsExpr: true}),
+  _this: kw("this", startsExpr),
+  _super: kw("super", startsExpr),
+  _class: kw("class", startsExpr),
+  _extends: kw("extends", beforeExpr),
+  _export: kw("export"),
+  _import: kw("import", startsExpr),
+  _null: kw("null", startsExpr),
+  _true: kw("true", startsExpr),
+  _false: kw("false", startsExpr),
+  _in: kw("in", {beforeExpr: true, binop: 7}),
+  _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
+  _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
+  _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
+  _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
+};
+
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
+
+var lineBreak = /\r\n?|\n|\u2028|\u2029/;
+var lineBreakG = new RegExp(lineBreak.source, "g");
+
+function isNewLine(code, ecma2019String) {
+  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))
+}
+
+var nonASCIIwhitespace = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+
+var ref = Object.prototype;
+var hasOwnProperty = ref.hasOwnProperty;
+var toString = ref.toString;
+
+// Checks if an object has a property.
+
+function has(obj, propName) {
+  return hasOwnProperty.call(obj, propName)
+}
+
+var isArray = Array.isArray || (function (obj) { return (
+  toString.call(obj) === "[object Array]"
+); });
+
+function wordsRegexp(words) {
+  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
+}
+
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
+
+var Position = function Position(line, col) {
+  this.line = line;
+  this.column = col;
+};
+
+Position.prototype.offset = function offset (n) {
+  return new Position(this.line, this.column + n)
+};
+
+var SourceLocation = function SourceLocation(p, start, end) {
+  this.start = start;
+  this.end = end;
+  if (p.sourceFile !== null) { this.source = p.sourceFile; }
+};
+
+// The `getLineInfo` function is mostly useful when the
+// `locations` option is off (for performance reasons) and you
+// want to find the line/column position for a given character
+// offset. `input` should be the code string that the offset refers
+// into.
+
+function getLineInfo(input, offset) {
+  for (var line = 1, cur = 0;;) {
+    lineBreakG.lastIndex = cur;
+    var match = lineBreakG.exec(input);
+    if (match && match.index < offset) {
+      ++line;
+      cur = match.index + match[0].length;
+    } else {
+      return new Position(line, offset - cur)
+    }
+  }
+}
+
+// A second optional argument can be given to further configure
+// the parser process. These options are recognized:
+
+var defaultOptions = {
+  // `ecmaVersion` indicates the ECMAScript version to parse. Must be
+  // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10
+  // (2019). This influences support for strict mode, the set of
+  // reserved words, and support for new syntax features. The default
+  // is 9.
+  ecmaVersion: 9,
+  // `sourceType` indicates the mode the code should be parsed in.
+  // Can be either `"script"` or `"module"`. This influences global
+  // strict mode and parsing of `import` and `export` declarations.
+  sourceType: "script",
+  // `onInsertedSemicolon` can be a callback that will be called
+  // when a semicolon is automatically inserted. It will be passed
+  // the position of the comma as an offset, and if `locations` is
+  // enabled, it is given the location as a `{line, column}` object
+  // as second argument.
+  onInsertedSemicolon: null,
+  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+  // trailing commas.
+  onTrailingComma: null,
+  // By default, reserved words are only enforced if ecmaVersion >= 5.
+  // Set `allowReserved` to a boolean value to explicitly turn this on
+  // an off. When this option has the value "never", reserved words
+  // and keywords can also not be used as property names.
+  allowReserved: null,
+  // When enabled, a return at the top level is not considered an
+  // error.
+  allowReturnOutsideFunction: false,
+  // When enabled, import/export statements are not constrained to
+  // appearing at the top of the program.
+  allowImportExportEverywhere: false,
+  // When enabled, await identifiers are allowed to appear at the top-level scope,
+  // but they are still not allowed in non-async functions.
+  allowAwaitOutsideFunction: false,
+  // When enabled, hashbang directive in the beginning of file
+  // is allowed and treated as a line comment.
+  allowHashBang: false,
+  // When `locations` is on, `loc` properties holding objects with
+  // `start` and `end` properties in `{line, column}` form (with
+  // line being 1-based and column 0-based) will be attached to the
+  // nodes.
+  locations: false,
+  // A function can be passed as `onToken` option, which will
+  // cause Acorn to call that function with object in the same
+  // format as tokens returned from `tokenizer().getToken()`. Note
+  // that you are not allowed to call the parser from the
+  // callback—that will corrupt its internal state.
+  onToken: null,
+  // A function can be passed as `onComment` option, which will
+  // cause Acorn to call that function with `(block, text, start,
+  // end)` parameters whenever a comment is skipped. `block` is a
+  // boolean indicating whether this is a block (`/* */`) comment,
+  // `text` is the content of the comment, and `start` and `end` are
+  // character offsets that denote the start and end of the comment.
+  // When the `locations` option is on, two more parameters are
+  // passed, the full `{line, column}` locations of the start and
+  // end of the comments. Note that you are not allowed to call the
+  // parser from the callback—that will corrupt its internal state.
+  onComment: null,
+  // Nodes have their start and end characters offsets recorded in
+  // `start` and `end` properties (directly on the node, rather than
+  // the `loc` object, which holds line/column data. To also add a
+  // [semi-standardized][range] `range` property holding a `[start,
+  // end]` array with the same numbers, set the `ranges` option to
+  // `true`.
+  //
+  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+  ranges: false,
+  // It is possible to parse multiple files into a single AST by
+  // passing the tree produced by parsing the first file as
+  // `program` option in subsequent parses. This will add the
+  // toplevel forms of the parsed file to the `Program` (top) node
+  // of an existing parse tree.
+  program: null,
+  // When `locations` is on, you can pass this to record the source
+  // file in every node's `loc` object.
+  sourceFile: null,
+  // This value, if given, is stored in every node, whether
+  // `locations` is on or off.
+  directSourceFile: null,
+  // When enabled, parenthesized expressions are represented by
+  // (non-standard) ParenthesizedExpression nodes
+  preserveParens: false
+};
+
+// Interpret and default an options object
+
+function getOptions(opts) {
+  var options = {};
+
+  for (var opt in defaultOptions)
+    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
+
+  if (options.ecmaVersion >= 2015)
+    { options.ecmaVersion -= 2009; }
+
+  if (options.allowReserved == null)
+    { options.allowReserved = options.ecmaVersion < 5; }
+
+  if (isArray(options.onToken)) {
+    var tokens = options.onToken;
+    options.onToken = function (token) { return tokens.push(token); };
+  }
+  if (isArray(options.onComment))
+    { options.onComment = pushComment(options, options.onComment); }
+
+  return options
+}
+
+function pushComment(options, array) {
+  return function(block, text, start, end, startLoc, endLoc) {
+    var comment = {
+      type: block ? "Block" : "Line",
+      value: text,
+      start: start,
+      end: end
+    };
+    if (options.locations)
+      { comment.loc = new SourceLocation(this, startLoc, endLoc); }
+    if (options.ranges)
+      { comment.range = [start, end]; }
+    array.push(comment);
+  }
+}
+
+// Each scope gets a bitset that may contain these flags
+var
+    SCOPE_TOP = 1,
+    SCOPE_FUNCTION = 2,
+    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,
+    SCOPE_ASYNC = 4,
+    SCOPE_GENERATOR = 8,
+    SCOPE_ARROW = 16,
+    SCOPE_SIMPLE_CATCH = 32,
+    SCOPE_SUPER = 64,
+    SCOPE_DIRECT_SUPER = 128;
+
+function functionFlags(async, generator) {
+  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)
+}
+
+// Used in checkLVal and declareName to determine the type of a binding
+var
+    BIND_NONE = 0, // Not a binding
+    BIND_VAR = 1, // Var-style binding
+    BIND_LEXICAL = 2, // Let- or const-style binding
+    BIND_FUNCTION = 3, // Function declaration
+    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding
+    BIND_OUTSIDE = 5; // Special case for function names as bound inside the function
+
+var Parser = function Parser(options, input, startPos) {
+  this.options = options = getOptions(options);
+  this.sourceFile = options.sourceFile;
+  this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
+  var reserved = "";
+  if (options.allowReserved !== true) {
+    for (var v = options.ecmaVersion;; v--)
+      { if (reserved = reservedWords[v]) { break } }
+    if (options.sourceType === "module") { reserved += " await"; }
+  }
+  this.reservedWords = wordsRegexp(reserved);
+  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
+  this.reservedWordsStrict = wordsRegexp(reservedStrict);
+  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords.strictBind);
+  this.input = String(input);
+
+  // Used to signal to callers of `readWord1` whether the word
+  // contained any escape sequences. This is needed because words with
+  // escape sequences must not be interpreted as keywords.
+  this.containsEsc = false;
+
+  // Set up token state
+
+  // The current position of the tokenizer in the input.
+  if (startPos) {
+    this.pos = startPos;
+    this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
+    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+  } else {
+    this.pos = this.lineStart = 0;
+    this.curLine = 1;
+  }
+
+  // Properties of the current token:
+  // Its type
+  this.type = types.eof;
+  // For tokens that include more information than their type, the value
+  this.value = null;
+  // Its start and end offset
+  this.start = this.end = this.pos;
+  // And, if locations are used, the {line, column} object
+  // corresponding to those offsets
+  this.startLoc = this.endLoc = this.curPosition();
+
+  // Position information for the previous token
+  this.lastTokEndLoc = this.lastTokStartLoc = null;
+  this.lastTokStart = this.lastTokEnd = this.pos;
+
+  // The context stack is used to superficially track syntactic
+  // context to predict whether a regular expression is allowed in a
+  // given position.
+  this.context = this.initialContext();
+  this.exprAllowed = true;
+
+  // Figure out if it's a module code.
+  this.inModule = options.sourceType === "module";
+  this.strict = this.inModule || this.strictDirective(this.pos);
+
+  // Used to signify the start of a potential arrow function
+  this.potentialArrowAt = -1;
+
+  // Positions to delayed-check that yield/await does not exist in default parameters.
+  this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
+  // Labels in scope.
+  this.labels = [];
+  // Thus-far undefined exports.
+  this.undefinedExports = {};
+
+  // If enabled, skip leading hashbang line.
+  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
+    { this.skipLineComment(2); }
+
+  // Scope tracking for duplicate variable names (see scope.js)
+  this.scopeStack = [];
+  this.enterScope(SCOPE_TOP);
+
+  // For RegExp validation
+  this.regexpState = null;
+};
+
+var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true } };
+
+Parser.prototype.parse = function parse () {
+  var node = this.options.program || this.startNode();
+  this.nextToken();
+  return this.parseTopLevel(node)
+};
+
+prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
+prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };
+prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };
+prototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };
+prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
+prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
+
+// Switch to a getter for 7.0.0.
+Parser.prototype.inNonArrowFunction = function inNonArrowFunction () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };
+
+Parser.extend = function extend () {
+    var plugins = [], len = arguments.length;
+    while ( len-- ) plugins[ len ] = arguments[ len ];
+
+  var cls = this;
+  for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); }
+  return cls
+};
+
+Parser.parse = function parse (input, options) {
+  return new this(options, input).parse()
+};
+
+Parser.parseExpressionAt = function parseExpressionAt (input, pos, options) {
+  var parser = new this(options, input, pos);
+  parser.nextToken();
+  return parser.parseExpression()
+};
+
+Parser.tokenizer = function tokenizer (input, options) {
+  return new this(options, input)
+};
+
+Object.defineProperties( Parser.prototype, prototypeAccessors );
+
+var pp = Parser.prototype;
+
+// ## Parser utilities
+
+var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)")/;
+pp.strictDirective = function(start) {
+  for (;;) {
+    // Try to find string literal.
+    skipWhiteSpace.lastIndex = start;
+    start += skipWhiteSpace.exec(this.input)[0].length;
+    var match = literal.exec(this.input.slice(start));
+    if (!match) { return false }
+    if ((match[1] || match[2]) === "use strict") { return true }
+    start += match[0].length;
+
+    // Skip semicolon, if any.
+    skipWhiteSpace.lastIndex = start;
+    start += skipWhiteSpace.exec(this.input)[0].length;
+    if (this.input[start] === ";")
+      { start++; }
+  }
+};
+
+// Predicate that tests whether the next token is of the given
+// type, and if yes, consumes it as a side effect.
+
+pp.eat = function(type) {
+  if (this.type === type) {
+    this.next();
+    return true
+  } else {
+    return false
+  }
+};
+
+// Tests whether parsed token is a contextual keyword.
+
+pp.isContextual = function(name) {
+  return this.type === types.name && this.value === name && !this.containsEsc
+};
+
+// Consumes contextual keyword if possible.
+
+pp.eatContextual = function(name) {
+  if (!this.isContextual(name)) { return false }
+  this.next();
+  return true
+};
+
+// Asserts that following token is given contextual keyword.
+
+pp.expectContextual = function(name) {
+  if (!this.eatContextual(name)) { this.unexpected(); }
+};
+
+// Test whether a semicolon can be inserted at the current position.
+
+pp.canInsertSemicolon = function() {
+  return this.type === types.eof ||
+    this.type === types.braceR ||
+    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+pp.insertSemicolon = function() {
+  if (this.canInsertSemicolon()) {
+    if (this.options.onInsertedSemicolon)
+      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
+    return true
+  }
+};
+
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
+
+pp.semicolon = function() {
+  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
+};
+
+pp.afterTrailingComma = function(tokType, notNext) {
+  if (this.type === tokType) {
+    if (this.options.onTrailingComma)
+      { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
+    if (!notNext)
+      { this.next(); }
+    return true
+  }
+};
+
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error.
+
+pp.expect = function(type) {
+  this.eat(type) || this.unexpected();
+};
+
+// Raise an unexpected token error.
+
+pp.unexpected = function(pos) {
+  this.raise(pos != null ? pos : this.start, "Unexpected token");
+};
+
+function DestructuringErrors() {
+  this.shorthandAssign =
+  this.trailingComma =
+  this.parenthesizedAssign =
+  this.parenthesizedBind =
+  this.doubleProto =
+    -1;
+}
+
+pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
+  if (!refDestructuringErrors) { return }
+  if (refDestructuringErrors.trailingComma > -1)
+    { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
+  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
+  if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
+};
+
+pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
+  if (!refDestructuringErrors) { return false }
+  var shorthandAssign = refDestructuringErrors.shorthandAssign;
+  var doubleProto = refDestructuringErrors.doubleProto;
+  if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
+  if (shorthandAssign >= 0)
+    { this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); }
+  if (doubleProto >= 0)
+    { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
+};
+
+pp.checkYieldAwaitInDefaultParams = function() {
+  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
+    { this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
+  if (this.awaitPos)
+    { this.raise(this.awaitPos, "Await expression cannot be a default value"); }
+};
+
+pp.isSimpleAssignTarget = function(expr) {
+  if (expr.type === "ParenthesizedExpression")
+    { return this.isSimpleAssignTarget(expr.expression) }
+  return expr.type === "Identifier" || expr.type === "MemberExpression"
+};
+
+var pp$1 = Parser.prototype;
+
+// ### Statement parsing
+
+// Parse a program. Initializes the parser, reads any number of
+// statements, and wraps them in a Program node.  Optionally takes a
+// `program` argument.  If present, the statements will be appended
+// to its body instead of creating a new node.
+
+pp$1.parseTopLevel = function(node) {
+  var exports = {};
+  if (!node.body) { node.body = []; }
+  while (this.type !== types.eof) {
+    var stmt = this.parseStatement(null, true, exports);
+    node.body.push(stmt);
+  }
+  if (this.inModule)
+    { for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1)
+      {
+        var name = list[i];
+
+        this.raiseRecoverable(this.undefinedExports[name].start, ("Export '" + name + "' is not defined"));
+      } }
+  this.adaptDirectivePrologue(node.body);
+  this.next();
+  node.sourceType = this.options.sourceType;
+  return this.finishNode(node, "Program")
+};
+
+var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+pp$1.isLet = function(context) {
+  if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+  // For ambiguous cases, determine if a LexicalDeclaration (or only a
+  // Statement) is allowed here. If context is not empty then only a Statement
+  // is allowed. However, `let [` is an explicit negative lookahead for
+  // ExpressionStatement, so special-case it first.
+  if (nextCh === 91) { return true } // '['
+  if (context) { return false }
+
+  if (nextCh === 123) { return true } // '{'
+  if (isIdentifierStart(nextCh, true)) {
+    var pos = next + 1;
+    while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }
+    var ident = this.input.slice(next, pos);
+    if (!keywordRelationalOperator.test(ident)) { return true }
+  }
+  return false
+};
+
+// check 'async [no LineTerminator here] function'
+// - 'async /*foo*/ function' is OK.
+// - 'async /*\n*/ function' is invalid.
+pp$1.isAsyncFunction = function() {
+  if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
+    { return false }
+
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length;
+  return !lineBreak.test(this.input.slice(this.pos, next)) &&
+    this.input.slice(next, next + 8) === "function" &&
+    (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
+};
+
+// Parse a single statement.
+//
+// If expecting a statement and finding a slash operator, parse a
+// regular expression literal. This is to handle cases like
+// `if (foo) /blah/.exec(foo)`, where looking at the previous token
+// does not help.
+
+pp$1.parseStatement = function(context, topLevel, exports) {
+  var starttype = this.type, node = this.startNode(), kind;
+
+  if (this.isLet(context)) {
+    starttype = types._var;
+    kind = "let";
+  }
+
+  // Most types of statements are recognized by the keyword they
+  // start with. Many are trivial to parse, some require a bit of
+  // complexity.
+
+  switch (starttype) {
+  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+  case types._debugger: return this.parseDebuggerStatement(node)
+  case types._do: return this.parseDoStatement(node)
+  case types._for: return this.parseForStatement(node)
+  case types._function:
+    // Function as sole body of either an if statement or a labeled statement
+    // works, but not when it is part of a labeled statement that is the sole
+    // body of an if statement.
+    if ((context && (this.strict || context !== "if" && context !== "label")) && this.options.ecmaVersion >= 6) { this.unexpected(); }
+    return this.parseFunctionStatement(node, false, !context)
+  case types._class:
+    if (context) { this.unexpected(); }
+    return this.parseClass(node, true)
+  case types._if: return this.parseIfStatement(node)
+  case types._return: return this.parseReturnStatement(node)
+  case types._switch: return this.parseSwitchStatement(node)
+  case types._throw: return this.parseThrowStatement(node)
+  case types._try: return this.parseTryStatement(node)
+  case types._const: case types._var:
+    kind = kind || this.value;
+    if (context && kind !== "var") { this.unexpected(); }
+    return this.parseVarStatement(node, kind)
+  case types._while: return this.parseWhileStatement(node)
+  case types._with: return this.parseWithStatement(node)
+  case types.braceL: return this.parseBlock(true, node)
+  case types.semi: return this.parseEmptyStatement(node)
+  case types._export:
+  case types._import:
+    if (this.options.ecmaVersion > 10 && starttype === types._import) {
+      skipWhiteSpace.lastIndex = this.pos;
+      var skip = skipWhiteSpace.exec(this.input);
+      var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+      if (nextCh === 40) // '('
+        { return this.parseExpressionStatement(node, this.parseExpression()) }
+    }
+
+    if (!this.options.allowImportExportEverywhere) {
+      if (!topLevel)
+        { this.raise(this.start, "'import' and 'export' may only appear at the top level"); }
+      if (!this.inModule)
+        { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
+    }
+    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
+
+    // If the statement does not start with a statement keyword or a
+    // brace, it's an ExpressionStatement or LabeledStatement. We
+    // simply start parsing an expression, and afterwards, if the
+    // next token is a colon and the expression was a simple
+    // Identifier node, we switch to interpreting it as a label.
+  default:
+    if (this.isAsyncFunction()) {
+      if (context) { this.unexpected(); }
+      this.next();
+      return this.parseFunctionStatement(node, true, !context)
+    }
+
+    var maybeName = this.value, expr = this.parseExpression();
+    if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
+      { return this.parseLabeledStatement(node, maybeName, expr, context) }
+    else { return this.parseExpressionStatement(node, expr) }
+  }
+};
+
+pp$1.parseBreakContinueStatement = function(node, keyword) {
+  var isBreak = keyword === "break";
+  this.next();
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
+  else if (this.type !== types.name) { this.unexpected(); }
+  else {
+    node.label = this.parseIdent();
+    this.semicolon();
+  }
+
+  // Verify that there is an actual destination to break or
+  // continue to.
+  var i = 0;
+  for (; i < this.labels.length; ++i) {
+    var lab = this.labels[i];
+    if (node.label == null || lab.name === node.label.name) {
+      if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
+      if (node.label && isBreak) { break }
+    }
+  }
+  if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); }
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+};
+
+pp$1.parseDebuggerStatement = function(node) {
+  this.next();
+  this.semicolon();
+  return this.finishNode(node, "DebuggerStatement")
+};
+
+pp$1.parseDoStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement("do");
+  this.labels.pop();
+  this.expect(types._while);
+  node.test = this.parseParenExpression();
+  if (this.options.ecmaVersion >= 6)
+    { this.eat(types.semi); }
+  else
+    { this.semicolon(); }
+  return this.finishNode(node, "DoWhileStatement")
+};
+
+// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+// loop is non-trivial. Basically, we have to parse the init `var`
+// statement or expression, disallowing the `in` operator (see
+// the second parameter to `parseExpression`), and then check
+// whether the next token is `in` or `of`. When there is no init
+// part (semicolon immediately after the opening parenthesis), it
+// is a regular `for` loop.
+
+pp$1.parseForStatement = function(node) {
+  this.next();
+  var awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual("await")) ? this.lastTokStart : -1;
+  this.labels.push(loopLabel);
+  this.enterScope(0);
+  this.expect(types.parenL);
+  if (this.type === types.semi) {
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    return this.parseFor(node, null)
+  }
+  var isLet = this.isLet();
+  if (this.type === types._var || this.type === types._const || isLet) {
+    var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
+    this.next();
+    this.parseVar(init$1, true, kind);
+    this.finishNode(init$1, "VariableDeclaration");
+    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
+      if (this.options.ecmaVersion >= 9) {
+        if (this.type === types._in) {
+          if (awaitAt > -1) { this.unexpected(awaitAt); }
+        } else { node.await = awaitAt > -1; }
+      }
+      return this.parseForIn(node, init$1)
+    }
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    return this.parseFor(node, init$1)
+  }
+  var refDestructuringErrors = new DestructuringErrors;
+  var init = this.parseExpression(true, refDestructuringErrors);
+  if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+    if (this.options.ecmaVersion >= 9) {
+      if (this.type === types._in) {
+        if (awaitAt > -1) { this.unexpected(awaitAt); }
+      } else { node.await = awaitAt > -1; }
+    }
+    this.toAssignable(init, false, refDestructuringErrors);
+    this.checkLVal(init);
+    return this.parseForIn(node, init)
+  } else {
+    this.checkExpressionErrors(refDestructuringErrors, true);
+  }
+  if (awaitAt > -1) { this.unexpected(awaitAt); }
+  return this.parseFor(node, init)
+};
+
+pp$1.parseFunctionStatement = function(node, isAsync, declarationPosition) {
+  this.next();
+  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
+};
+
+pp$1.parseIfStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  // allow function declarations in branches, but only in non-strict mode
+  node.consequent = this.parseStatement("if");
+  node.alternate = this.eat(types._else) ? this.parseStatement("if") : null;
+  return this.finishNode(node, "IfStatement")
+};
+
+pp$1.parseReturnStatement = function(node) {
+  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+    { this.raise(this.start, "'return' outside of function"); }
+  this.next();
+
+  // In `return` (and `break`/`continue`), the keywords with
+  // optional arguments, we eagerly look for a semicolon or the
+  // possibility to insert one.
+
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
+  else { node.argument = this.parseExpression(); this.semicolon(); }
+  return this.finishNode(node, "ReturnStatement")
+};
+
+pp$1.parseSwitchStatement = function(node) {
+  this.next();
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
+  this.expect(types.braceL);
+  this.labels.push(switchLabel);
+  this.enterScope(0);
+
+  // Statements under must be grouped (by label) in SwitchCase
+  // nodes. `cur` is used to keep the node that we are currently
+  // adding statements to.
+
+  var cur;
+  for (var sawDefault = false; this.type !== types.braceR;) {
+    if (this.type === types._case || this.type === types._default) {
+      var isCase = this.type === types._case;
+      if (cur) { this.finishNode(cur, "SwitchCase"); }
+      node.cases.push(cur = this.startNode());
+      cur.consequent = [];
+      this.next();
+      if (isCase) {
+        cur.test = this.parseExpression();
+      } else {
+        if (sawDefault) { this.raiseRecoverable(this.lastTokStart, "Multiple default clauses"); }
+        sawDefault = true;
+        cur.test = null;
+      }
+      this.expect(types.colon);
+    } else {
+      if (!cur) { this.unexpected(); }
+      cur.consequent.push(this.parseStatement(null));
+    }
+  }
+  this.exitScope();
+  if (cur) { this.finishNode(cur, "SwitchCase"); }
+  this.next(); // Closing brace
+  this.labels.pop();
+  return this.finishNode(node, "SwitchStatement")
+};
+
+pp$1.parseThrowStatement = function(node) {
+  this.next();
+  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
+    { this.raise(this.lastTokEnd, "Illegal newline after throw"); }
+  node.argument = this.parseExpression();
+  this.semicolon();
+  return this.finishNode(node, "ThrowStatement")
+};
+
+// Reused empty array added for node fields that are always empty.
+
+var empty = [];
+
+pp$1.parseTryStatement = function(node) {
+  this.next();
+  node.block = this.parseBlock();
+  node.handler = null;
+  if (this.type === types._catch) {
+    var clause = this.startNode();
+    this.next();
+    if (this.eat(types.parenL)) {
+      clause.param = this.parseBindingAtom();
+      var simple = clause.param.type === "Identifier";
+      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
+      this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
+      this.expect(types.parenR);
+    } else {
+      if (this.options.ecmaVersion < 10) { this.unexpected(); }
+      clause.param = null;
+      this.enterScope(0);
+    }
+    clause.body = this.parseBlock(false);
+    this.exitScope();
+    node.handler = this.finishNode(clause, "CatchClause");
+  }
+  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
+  if (!node.handler && !node.finalizer)
+    { this.raise(node.start, "Missing catch or finally clause"); }
+  return this.finishNode(node, "TryStatement")
+};
+
+pp$1.parseVarStatement = function(node, kind) {
+  this.next();
+  this.parseVar(node, false, kind);
+  this.semicolon();
+  return this.finishNode(node, "VariableDeclaration")
+};
+
+pp$1.parseWhileStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement("while");
+  this.labels.pop();
+  return this.finishNode(node, "WhileStatement")
+};
+
+pp$1.parseWithStatement = function(node) {
+  if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
+  this.next();
+  node.object = this.parseParenExpression();
+  node.body = this.parseStatement("with");
+  return this.finishNode(node, "WithStatement")
+};
+
+pp$1.parseEmptyStatement = function(node) {
+  this.next();
+  return this.finishNode(node, "EmptyStatement")
+};
+
+pp$1.parseLabeledStatement = function(node, maybeName, expr, context) {
+  for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1)
+    {
+    var label = list[i$1];
+
+    if (label.name === maybeName)
+      { this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+  } }
+  var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
+  for (var i = this.labels.length - 1; i >= 0; i--) {
+    var label$1 = this.labels[i];
+    if (label$1.statementStart === node.start) {
+      // Update information about previous labels on this node
+      label$1.statementStart = this.start;
+      label$1.kind = kind;
+    } else { break }
+  }
+  this.labels.push({name: maybeName, kind: kind, statementStart: this.start});
+  node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+  this.labels.pop();
+  node.label = expr;
+  return this.finishNode(node, "LabeledStatement")
+};
+
+pp$1.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
+  this.semicolon();
+  return this.finishNode(node, "ExpressionStatement")
+};
+
+// Parse a semicolon-enclosed block of statements, handling `"use
+// strict"` declarations when `allowStrict` is true (used for
+// function bodies).
+
+pp$1.parseBlock = function(createNewLexicalScope, node) {
+  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
+  if ( node === void 0 ) node = this.startNode();
+
+  node.body = [];
+  this.expect(types.braceL);
+  if (createNewLexicalScope) { this.enterScope(0); }
+  while (!this.eat(types.braceR)) {
+    var stmt = this.parseStatement(null);
+    node.body.push(stmt);
+  }
+  if (createNewLexicalScope) { this.exitScope(); }
+  return this.finishNode(node, "BlockStatement")
+};
+
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
+
+pp$1.parseFor = function(node, init) {
+  node.init = init;
+  this.expect(types.semi);
+  node.test = this.type === types.semi ? null : this.parseExpression();
+  this.expect(types.semi);
+  node.update = this.type === types.parenR ? null : this.parseExpression();
+  this.expect(types.parenR);
+  node.body = this.parseStatement("for");
+  this.exitScope();
+  this.labels.pop();
+  return this.finishNode(node, "ForStatement")
+};
+
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
+
+pp$1.parseForIn = function(node, init) {
+  var isForIn = this.type === types._in;
+  this.next();
+
+  if (
+    init.type === "VariableDeclaration" &&
+    init.declarations[0].init != null &&
+    (
+      !isForIn ||
+      this.options.ecmaVersion < 8 ||
+      this.strict ||
+      init.kind !== "var" ||
+      init.declarations[0].id.type !== "Identifier"
+    )
+  ) {
+    this.raise(
+      init.start,
+      ((isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer")
+    );
+  } else if (init.type === "AssignmentPattern") {
+    this.raise(init.start, "Invalid left-hand side in for-loop");
+  }
+  node.left = init;
+  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
+  this.expect(types.parenR);
+  node.body = this.parseStatement("for");
+  this.exitScope();
+  this.labels.pop();
+  return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement")
+};
+
+// Parse a list of variable declarations.
+
+pp$1.parseVar = function(node, isFor, kind) {
+  node.declarations = [];
+  node.kind = kind;
+  for (;;) {
+    var decl = this.startNode();
+    this.parseVarId(decl, kind);
+    if (this.eat(types.eq)) {
+      decl.init = this.parseMaybeAssign(isFor);
+    } else if (kind === "const" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+      this.unexpected();
+    } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types._in || this.isContextual("of")))) {
+      this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
+    } else {
+      decl.init = null;
+    }
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+    if (!this.eat(types.comma)) { break }
+  }
+  return node
+};
+
+pp$1.parseVarId = function(decl, kind) {
+  decl.id = this.parseBindingAtom();
+  this.checkLVal(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
+};
+
+var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
+
+// Parse a function declaration or literal (depending on the
+// `statement & FUNC_STATEMENT`).
+
+// Remove `allowExpressionBody` for 7.0.0, as it is only called with false
+pp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
+    if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))
+      { this.unexpected(); }
+    node.generator = this.eat(types.star);
+  }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  if (statement & FUNC_STATEMENT) {
+    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();
+    if (node.id && !(statement & FUNC_HANGING_STATEMENT))
+      // If it is a regular function declaration in sloppy mode, then it is
+      // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
+      // mode depends on properties of the current scope (see
+      // treatFunctionsAsVar).
+      { this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }
+  }
+
+  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.awaitIdentPos = 0;
+  this.enterScope(functionFlags(node.async, node.generator));
+
+  if (!(statement & FUNC_STATEMENT))
+    { node.id = this.type === types.name ? this.parseIdent() : null; }
+
+  this.parseFunctionParams(node);
+  this.parseFunctionBody(node, allowExpressionBody, false);
+
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.awaitIdentPos = oldAwaitIdentPos;
+  return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
+};
+
+pp$1.parseFunctionParams = function(node) {
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+};
+
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp$1.parseClass = function(node, isStatement) {
+  this.next();
+
+  // ecma-262 14.6 Class Definitions
+  // A class definition is always strict mode code.
+  var oldStrict = this.strict;
+  this.strict = true;
+
+  this.parseClassId(node, isStatement);
+  this.parseClassSuper(node);
+  var classBody = this.startNode();
+  var hadConstructor = false;
+  classBody.body = [];
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    var element = this.parseClassElement(node.superClass !== null);
+    if (element) {
+      classBody.body.push(element);
+      if (element.type === "MethodDefinition" && element.kind === "constructor") {
+        if (hadConstructor) { this.raise(element.start, "Duplicate constructor in the same class"); }
+        hadConstructor = true;
+      }
+    }
+  }
+  node.body = this.finishNode(classBody, "ClassBody");
+  this.strict = oldStrict;
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+};
+
+pp$1.parseClassElement = function(constructorAllowsSuper) {
+  var this$1 = this;
+
+  if (this.eat(types.semi)) { return null }
+
+  var method = this.startNode();
+  var tryContextual = function (k, noLineBreak) {
+    if ( noLineBreak === void 0 ) noLineBreak = false;
+
+    var start = this$1.start, startLoc = this$1.startLoc;
+    if (!this$1.eatContextual(k)) { return false }
+    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
+    if (method.key) { this$1.unexpected(); }
+    method.computed = false;
+    method.key = this$1.startNodeAt(start, startLoc);
+    method.key.name = k;
+    this$1.finishNode(method.key, "Identifier");
+    return false
+  };
+
+  method.kind = "method";
+  method.static = tryContextual("static");
+  var isGenerator = this.eat(types.star);
+  var isAsync = false;
+  if (!isGenerator) {
+    if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+      isAsync = true;
+      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+    } else if (tryContextual("get")) {
+      method.kind = "get";
+    } else if (tryContextual("set")) {
+      method.kind = "set";
+    }
+  }
+  if (!method.key) { this.parsePropertyName(method); }
+  var key = method.key;
+  var allowsDirectSuper = false;
+  if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
+      key.type === "Literal" && key.value === "constructor")) {
+    if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
+    if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
+    if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
+    method.kind = "constructor";
+    allowsDirectSuper = constructorAllowsSuper;
+  } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
+    this.raise(key.start, "Classes may not have a static property named prototype");
+  }
+  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);
+  if (method.kind === "get" && method.value.params.length !== 0)
+    { this.raiseRecoverable(method.value.start, "getter should have no params"); }
+  if (method.kind === "set" && method.value.params.length !== 1)
+    { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
+  if (method.kind === "set" && method.value.params[0].type === "RestElement")
+    { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
+  return method
+};
+
+pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+  return this.finishNode(method, "MethodDefinition")
+};
+
+pp$1.parseClassId = function(node, isStatement) {
+  if (this.type === types.name) {
+    node.id = this.parseIdent();
+    if (isStatement)
+      { this.checkLVal(node.id, BIND_LEXICAL, false); }
+  } else {
+    if (isStatement === true)
+      { this.unexpected(); }
+    node.id = null;
+  }
+};
+
+pp$1.parseClassSuper = function(node) {
+  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
+};
+
+// Parses module export declaration.
+
+pp$1.parseExport = function(node, exports) {
+  this.next();
+  // export * from '...'
+  if (this.eat(types.star)) {
+    this.expectContextual("from");
+    if (this.type !== types.string) { this.unexpected(); }
+    node.source = this.parseExprAtom();
+    this.semicolon();
+    return this.finishNode(node, "ExportAllDeclaration")
+  }
+  if (this.eat(types._default)) { // export default ...
+    this.checkExport(exports, "default", this.lastTokStart);
+    var isAsync;
+    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
+      var fNode = this.startNode();
+      this.next();
+      if (isAsync) { this.next(); }
+      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+    } else if (this.type === types._class) {
+      var cNode = this.startNode();
+      node.declaration = this.parseClass(cNode, "nullableID");
+    } else {
+      node.declaration = this.parseMaybeAssign();
+      this.semicolon();
+    }
+    return this.finishNode(node, "ExportDefaultDeclaration")
+  }
+  // export var|const|let|function|class ...
+  if (this.shouldParseExportStatement()) {
+    node.declaration = this.parseStatement(null);
+    if (node.declaration.type === "VariableDeclaration")
+      { this.checkVariableExport(exports, node.declaration.declarations); }
+    else
+      { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
+    node.specifiers = [];
+    node.source = null;
+  } else { // export { x, y as z } [from '...']
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers(exports);
+    if (this.eatContextual("from")) {
+      if (this.type !== types.string) { this.unexpected(); }
+      node.source = this.parseExprAtom();
+    } else {
+      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+        // check for keywords used as local names
+        var spec = list[i];
+
+        this.checkUnreserved(spec.local);
+        // check if export is defined
+        this.checkLocalExport(spec.local);
+      }
+
+      node.source = null;
+    }
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration")
+};
+
+pp$1.checkExport = function(exports, name, pos) {
+  if (!exports) { return }
+  if (has(exports, name))
+    { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
+  exports[name] = true;
+};
+
+pp$1.checkPatternExport = function(exports, pat) {
+  var type = pat.type;
+  if (type === "Identifier")
+    { this.checkExport(exports, pat.name, pat.start); }
+  else if (type === "ObjectPattern")
+    { for (var i = 0, list = pat.properties; i < list.length; i += 1)
+      {
+        var prop = list[i];
+
+        this.checkPatternExport(exports, prop);
+      } }
+  else if (type === "ArrayPattern")
+    { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
+      var elt = list$1[i$1];
+
+        if (elt) { this.checkPatternExport(exports, elt); }
+    } }
+  else if (type === "Property")
+    { this.checkPatternExport(exports, pat.value); }
+  else if (type === "AssignmentPattern")
+    { this.checkPatternExport(exports, pat.left); }
+  else if (type === "RestElement")
+    { this.checkPatternExport(exports, pat.argument); }
+  else if (type === "ParenthesizedExpression")
+    { this.checkPatternExport(exports, pat.expression); }
+};
+
+pp$1.checkVariableExport = function(exports, decls) {
+  if (!exports) { return }
+  for (var i = 0, list = decls; i < list.length; i += 1)
+    {
+    var decl = list[i];
+
+    this.checkPatternExport(exports, decl.id);
+  }
+};
+
+pp$1.shouldParseExportStatement = function() {
+  return this.type.keyword === "var" ||
+    this.type.keyword === "const" ||
+    this.type.keyword === "class" ||
+    this.type.keyword === "function" ||
+    this.isLet() ||
+    this.isAsyncFunction()
+};
+
+// Parses a comma-separated list of module exports.
+
+pp$1.parseExportSpecifiers = function(exports) {
+  var nodes = [], first = true;
+  // export { x, y as z } [from '...']
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (this.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
+
+    var node = this.startNode();
+    node.local = this.parseIdent(true);
+    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
+    this.checkExport(exports, node.exported.name, node.exported.start);
+    nodes.push(this.finishNode(node, "ExportSpecifier"));
+  }
+  return nodes
+};
+
+// Parses import declaration.
+
+pp$1.parseImport = function(node) {
+  this.next();
+  // import '...'
+  if (this.type === types.string) {
+    node.specifiers = empty;
+    node.source = this.parseExprAtom();
+  } else {
+    node.specifiers = this.parseImportSpecifiers();
+    this.expectContextual("from");
+    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
+  }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration")
+};
+
+// Parses a comma-separated list of module imports.
+
+pp$1.parseImportSpecifiers = function() {
+  var nodes = [], first = true;
+  if (this.type === types.name) {
+    // import defaultObj, { x, y as z } from '...'
+    var node = this.startNode();
+    node.local = this.parseIdent();
+    this.checkLVal(node.local, BIND_LEXICAL);
+    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
+    if (!this.eat(types.comma)) { return nodes }
+  }
+  if (this.type === types.star) {
+    var node$1 = this.startNode();
+    this.next();
+    this.expectContextual("as");
+    node$1.local = this.parseIdent();
+    this.checkLVal(node$1.local, BIND_LEXICAL);
+    nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
+    return nodes
+  }
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (this.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
+
+    var node$2 = this.startNode();
+    node$2.imported = this.parseIdent(true);
+    if (this.eatContextual("as")) {
+      node$2.local = this.parseIdent();
+    } else {
+      this.checkUnreserved(node$2.imported);
+      node$2.local = node$2.imported;
+    }
+    this.checkLVal(node$2.local, BIND_LEXICAL);
+    nodes.push(this.finishNode(node$2, "ImportSpecifier"));
+  }
+  return nodes
+};
+
+// Set `ExpressionStatement#directive` property for directive prologues.
+pp$1.adaptDirectivePrologue = function(statements) {
+  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
+    statements[i].directive = statements[i].expression.raw.slice(1, -1);
+  }
+};
+pp$1.isDirectiveCandidate = function(statement) {
+  return (
+    statement.type === "ExpressionStatement" &&
+    statement.expression.type === "Literal" &&
+    typeof statement.expression.value === "string" &&
+    // Reject parenthesized strings.
+    (this.input[statement.start] === "\"" || this.input[statement.start] === "'")
+  )
+};
+
+var pp$2 = Parser.prototype;
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
+    case "Identifier":
+      if (this.inAsync && node.name === "await")
+        { this.raise(node.start, "Cannot use 'await' as identifier inside an async function"); }
+      break
+
+    case "ObjectPattern":
+    case "ArrayPattern":
+    case "RestElement":
+      break
+
+    case "ObjectExpression":
+      node.type = "ObjectPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      for (var i = 0, list = node.properties; i < list.length; i += 1) {
+        var prop = list[i];
+
+      this.toAssignable(prop, isBinding);
+        // Early error:
+        //   AssignmentRestProperty[Yield, Await] :
+        //     `...` DestructuringAssignmentTarget[Yield, Await]
+        //
+        //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.
+        if (
+          prop.type === "RestElement" &&
+          (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")
+        ) {
+          this.raise(prop.argument.start, "Unexpected token");
+        }
+      }
+      break
+
+    case "Property":
+      // AssignmentProperty has type === "Property"
+      if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
+      this.toAssignable(node.value, isBinding);
+      break
+
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      this.toAssignableList(node.elements, isBinding);
+      break
+
+    case "SpreadElement":
+      node.type = "RestElement";
+      this.toAssignable(node.argument, isBinding);
+      if (node.argument.type === "AssignmentPattern")
+        { this.raise(node.argument.start, "Rest elements cannot have a default value"); }
+      break
+
+    case "AssignmentExpression":
+      if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); }
+      node.type = "AssignmentPattern";
+      delete node.operator;
+      this.toAssignable(node.left, isBinding);
+      // falls through to AssignmentPattern
+
+    case "AssignmentPattern":
+      break
+
+    case "ParenthesizedExpression":
+      this.toAssignable(node.expression, isBinding, refDestructuringErrors);
+      break
+
+    case "MemberExpression":
+      if (!isBinding) { break }
+
+    default:
+      this.raise(node.start, "Assigning to rvalue");
+    }
+  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+  return node
+};
+
+// Convert list of expression atoms to binding list.
+
+pp$2.toAssignableList = function(exprList, isBinding) {
+  var end = exprList.length;
+  for (var i = 0; i < end; i++) {
+    var elt = exprList[i];
+    if (elt) { this.toAssignable(elt, isBinding); }
+  }
+  if (end) {
+    var last = exprList[end - 1];
+    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
+      { this.unexpected(last.argument.start); }
+  }
+  return exprList
+};
+
+// Parses spread element.
+
+pp$2.parseSpread = function(refDestructuringErrors) {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+  return this.finishNode(node, "SpreadElement")
+};
+
+pp$2.parseRestBinding = function() {
+  var node = this.startNode();
+  this.next();
+
+  // RestElement inside of a function parameter must be an identifier
+  if (this.options.ecmaVersion === 6 && this.type !== types.name)
+    { this.unexpected(); }
+
+  node.argument = this.parseBindingAtom();
+
+  return this.finishNode(node, "RestElement")
+};
+
+// Parses lvalue (assignable) atom.
+
+pp$2.parseBindingAtom = function() {
+  if (this.options.ecmaVersion >= 6) {
+    switch (this.type) {
+    case types.bracketL:
+      var node = this.startNode();
+      this.next();
+      node.elements = this.parseBindingList(types.bracketR, true, true);
+      return this.finishNode(node, "ArrayPattern")
+
+    case types.braceL:
+      return this.parseObj(true)
+    }
+  }
+  return this.parseIdent()
+};
+
+pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (first) { first = false; }
+    else { this.expect(types.comma); }
+    if (allowEmpty && this.type === types.comma) {
+      elts.push(null);
+    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
+      break
+    } else if (this.type === types.ellipsis) {
+      var rest = this.parseRestBinding();
+      this.parseBindingListItem(rest);
+      elts.push(rest);
+      if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+      this.expect(close);
+      break
+    } else {
+      var elem = this.parseMaybeDefault(this.start, this.startLoc);
+      this.parseBindingListItem(elem);
+      elts.push(elem);
+    }
+  }
+  return elts
+};
+
+pp$2.parseBindingListItem = function(param) {
+  return param
+};
+
+// Parses assignment pattern around given atom if possible.
+
+pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
+  left = left || this.parseBindingAtom();
+  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.right = this.parseMaybeAssign();
+  return this.finishNode(node, "AssignmentPattern")
+};
+
+// Verify that a node is an lval — something that can be assigned
+// to.
+// bindingType can be either:
+// 'var' indicating that the lval creates a 'var' binding
+// 'let' indicating that the lval creates a lexical ('let' or 'const') binding
+// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references
+
+pp$2.checkLVal = function(expr, bindingType, checkClashes) {
+  if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+  switch (expr.type) {
+  case "Identifier":
+    if (bindingType === BIND_LEXICAL && expr.name === "let")
+      { this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name"); }
+    if (this.strict && this.reservedWordsStrictBind.test(expr.name))
+      { this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
+    if (checkClashes) {
+      if (has(checkClashes, expr.name))
+        { this.raiseRecoverable(expr.start, "Argument name clash"); }
+      checkClashes[expr.name] = true;
+    }
+    if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }
+    break
+
+  case "MemberExpression":
+    if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
+    break
+
+  case "ObjectPattern":
+    for (var i = 0, list = expr.properties; i < list.length; i += 1)
+      {
+    var prop = list[i];
+
+    this.checkLVal(prop, bindingType, checkClashes);
+  }
+    break
+
+  case "Property":
+    // AssignmentProperty has type === "Property"
+    this.checkLVal(expr.value, bindingType, checkClashes);
+    break
+
+  case "ArrayPattern":
+    for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
+      var elem = list$1[i$1];
+
+    if (elem) { this.checkLVal(elem, bindingType, checkClashes); }
+    }
+    break
+
+  case "AssignmentPattern":
+    this.checkLVal(expr.left, bindingType, checkClashes);
+    break
+
+  case "RestElement":
+    this.checkLVal(expr.argument, bindingType, checkClashes);
+    break
+
+  case "ParenthesizedExpression":
+    this.checkLVal(expr.expression, bindingType, checkClashes);
+    break
+
+  default:
+    this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
+  }
+};
+
+// A recursive descent parser operates by defining functions for all
+
+var pp$3 = Parser.prototype;
+
+// Check if property name clashes with already added.
+// Object/class getters and setters are not allowed to clash —
+// either with each other or with an init property — and in
+// strict mode, init properties are also not allowed to be repeated.
+
+pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
+    { return }
+  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
+    { return }
+  var key = prop.key;
+  var name;
+  switch (key.type) {
+  case "Identifier": name = key.name; break
+  case "Literal": name = String(key.value); break
+  default: return
+  }
+  var kind = prop.kind;
+  if (this.options.ecmaVersion >= 6) {
+    if (name === "__proto__" && kind === "init") {
+      if (propHash.proto) {
+        if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) { refDestructuringErrors.doubleProto = key.start; }
+        // Backwards-compat kludge. Can be removed in version 6.0
+        else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
+      }
+      propHash.proto = true;
+    }
+    return
+  }
+  name = "$" + name;
+  var other = propHash[name];
+  if (other) {
+    var redefinition;
+    if (kind === "init") {
+      redefinition = this.strict && other.init || other.get || other.set;
+    } else {
+      redefinition = other.init || other[kind];
+    }
+    if (redefinition)
+      { this.raiseRecoverable(key.start, "Redefinition of property"); }
+  } else {
+    other = propHash[name] = {
+      init: false,
+      get: false,
+      set: false
+    };
+  }
+  other[kind] = true;
+};
+
+// ### Expression parsing
+
+// These nest, from the most general expression type at the top to
+// 'atomic', nondivisible expression types at the bottom. Most of
+// the functions will simply let the function(s) below them parse,
+// and, *if* the syntactic construct they handle is present, wrap
+// the AST node that the inner parser gave them in another node.
+
+// Parse a full expression. The optional arguments are used to
+// forbid the `in` operator (in for loops initalization expressions)
+// and provide reference for storing '=' operator inside shorthand
+// property assignment in contexts where both object expression
+// and object pattern might appear (so it's possible to raise
+// delayed syntax error at correct position).
+
+pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
+  if (this.type === types.comma) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.expressions = [expr];
+    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }
+    return this.finishNode(node, "SequenceExpression")
+  }
+  return expr
+};
+
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
+
+pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+  if (this.isContextual("yield")) {
+    if (this.inGenerator) { return this.parseYield(noIn) }
+    // The tokenizer will assume an expression is allowed after
+    // `yield`, but this isn't that kind of yield
+    else { this.exprAllowed = false; }
+  }
+
+  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldShorthandAssign = -1;
+  if (refDestructuringErrors) {
+    oldParenAssign = refDestructuringErrors.parenthesizedAssign;
+    oldTrailingComma = refDestructuringErrors.trailingComma;
+    oldShorthandAssign = refDestructuringErrors.shorthandAssign;
+    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.shorthandAssign = -1;
+  } else {
+    refDestructuringErrors = new DestructuringErrors;
+    ownDestructuringErrors = true;
+  }
+
+  var startPos = this.start, startLoc = this.startLoc;
+  if (this.type === types.parenL || this.type === types.name)
+    { this.potentialArrowAt = this.start; }
+  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
+  if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
+  if (this.type.isAssign) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.operator = this.value;
+    node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
+    if (!ownDestructuringErrors) { DestructuringErrors.call(refDestructuringErrors); }
+    refDestructuringErrors.shorthandAssign = -1; // reset because shorthand default was used correctly
+    this.checkLVal(left);
+    this.next();
+    node.right = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "AssignmentExpression")
+  } else {
+    if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
+  }
+  if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }
+  if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }
+  if (oldShorthandAssign > -1) { refDestructuringErrors.shorthandAssign = oldShorthandAssign; }
+  return left
+};
+
+// Parse a ternary conditional (`?:`) operator.
+
+pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseExprOps(noIn, refDestructuringErrors);
+  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+  if (this.eat(types.question)) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    this.expect(types.colon);
+    node.alternate = this.parseMaybeAssign(noIn);
+    return this.finishNode(node, "ConditionalExpression")
+  }
+  return expr
+};
+
+// Start the precedence parser.
+
+pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseMaybeUnary(refDestructuringErrors, false);
+  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+};
+
+// Parse binary operators with the operator precedence parsing
+// algorithm. `left` is the left-hand side of the operator.
+// `minPrec` provides context that allows the function to stop and
+// defer further parser to one of its callers when it encounters an
+// operator that has a lower precedence than the set it is parsing.
+
+pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+  var prec = this.type.binop;
+  if (prec != null && (!noIn || this.type !== types._in)) {
+    if (prec > minPrec) {
+      var logical = this.type === types.logicalOR || this.type === types.logicalAND;
+      var op = this.value;
+      this.next();
+      var startPos = this.start, startLoc = this.startLoc;
+      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
+      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);
+      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+    }
+  }
+  return left
+};
+
+pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.operator = op;
+  node.right = right;
+  return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
+};
+
+// Parse unary operators, both prefix and postfix.
+
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+  var startPos = this.start, startLoc = this.startLoc, expr;
+  if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
+    expr = this.parseAwait();
+    sawUnary = true;
+  } else if (this.type.prefix) {
+    var node = this.startNode(), update = this.type === types.incDec;
+    node.operator = this.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary(null, true);
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    if (update) { this.checkLVal(node.argument); }
+    else if (this.strict && node.operator === "delete" &&
+             node.argument.type === "Identifier")
+      { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+    else { sawUnary = true; }
+    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  } else {
+    expr = this.parseExprSubscripts(refDestructuringErrors);
+    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+    while (this.type.postfix && !this.canInsertSemicolon()) {
+      var node$1 = this.startNodeAt(startPos, startLoc);
+      node$1.operator = this.value;
+      node$1.prefix = false;
+      node$1.argument = expr;
+      this.checkLVal(expr);
+      this.next();
+      expr = this.finishNode(node$1, "UpdateExpression");
+    }
+  }
+
+  if (!sawUnary && this.eat(types.starstar))
+    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+  else
+    { return expr }
+};
+
+// Parse call, dot, and `[]`-subscript expressions.
+
+pp$3.parseExprSubscripts = function(refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseExprAtom(refDestructuringErrors);
+  var skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")";
+  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) { return expr }
+  var result = this.parseSubscripts(expr, startPos, startLoc);
+  if (refDestructuringErrors && result.type === "MemberExpression") {
+    if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
+    if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+  }
+  return result
+};
+
+pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
+      this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
+  while (true) {
+    var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow);
+    if (element === base || element.type === "ArrowFunctionExpression") { return element }
+    base = element;
+  }
+};
+
+pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {
+  var computed = this.eat(types.bracketL);
+  if (computed || this.eat(types.dot)) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.object = base;
+    node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
+    node.computed = !!computed;
+    if (computed) { this.expect(types.bracketR); }
+    base = this.finishNode(node, "MemberExpression");
+  } else if (!noCalls && this.eat(types.parenL)) {
+    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    this.awaitIdentPos = 0;
+    var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8 && base.type !== "Import", false, refDestructuringErrors);
+    if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+      this.checkPatternErrors(refDestructuringErrors, false);
+      this.checkYieldAwaitInDefaultParams();
+      if (this.awaitIdentPos > 0)
+        { this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function"); }
+      this.yieldPos = oldYieldPos;
+      this.awaitPos = oldAwaitPos;
+      this.awaitIdentPos = oldAwaitIdentPos;
+      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)
+    }
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    this.yieldPos = oldYieldPos || this.yieldPos;
+    this.awaitPos = oldAwaitPos || this.awaitPos;
+    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;
+    var node$1 = this.startNodeAt(startPos, startLoc);
+    node$1.callee = base;
+    node$1.arguments = exprList;
+    if (node$1.callee.type === "Import") {
+      if (node$1.arguments.length !== 1) {
+        this.raise(node$1.start, "import() requires exactly one argument");
+      }
+
+      var importArg = node$1.arguments[0];
+      if (importArg && importArg.type === "SpreadElement") {
+        this.raise(importArg.start, "... is not allowed in import()");
+      }
+    }
+    base = this.finishNode(node$1, "CallExpression");
+  } else if (this.type === types.backQuote) {
+    var node$2 = this.startNodeAt(startPos, startLoc);
+    node$2.tag = base;
+    node$2.quasi = this.parseTemplate({isTagged: true});
+    base = this.finishNode(node$2, "TaggedTemplateExpression");
+  }
+  return base
+};
+
+// Parse an atomic expression — either a single token that is an
+// expression, an expression started by a keyword like `function` or
+// `new`, or an expression wrapped in punctuation like `()`, `[]`,
+// or `{}`.
+
+pp$3.parseExprAtom = function(refDestructuringErrors) {
+  // If a division operator appears in an expression position, the
+  // tokenizer got confused, and we force it to read a regexp instead.
+  if (this.type === types.slash) { this.readRegexp(); }
+
+  var node, canBeArrow = this.potentialArrowAt === this.start;
+  switch (this.type) {
+  case types._super:
+    if (!this.allowSuper)
+      { this.raise(this.start, "'super' keyword outside a method"); }
+    node = this.startNode();
+    this.next();
+    if (this.type === types.parenL && !this.allowDirectSuper)
+      { this.raise(node.start, "super() call outside constructor of a subclass"); }
+    // The `super` keyword can appear at below:
+    // SuperProperty:
+    //     super [ Expression ]
+    //     super . IdentifierName
+    // SuperCall:
+    //     super Arguments
+    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
+      { this.unexpected(); }
+    return this.finishNode(node, "Super")
+
+  case types._this:
+    node = this.startNode();
+    this.next();
+    return this.finishNode(node, "ThisExpression")
+
+  case types.name:
+    var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
+    var id = this.parseIdent(false);
+    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
+      { return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true) }
+    if (canBeArrow && !this.canInsertSemicolon()) {
+      if (this.eat(types.arrow))
+        { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
+      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
+        id = this.parseIdent(false);
+        if (this.canInsertSemicolon() || !this.eat(types.arrow))
+          { this.unexpected(); }
+        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
+      }
+    }
+    return id
+
+  case types.regexp:
+    var value = this.value;
+    node = this.parseLiteral(value.value);
+    node.regex = {pattern: value.pattern, flags: value.flags};
+    return node
+
+  case types.num: case types.string:
+    return this.parseLiteral(this.value)
+
+  case types._null: case types._true: case types._false:
+    node = this.startNode();
+    node.value = this.type === types._null ? null : this.type === types._true;
+    node.raw = this.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal")
+
+  case types.parenL:
+    var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
+    if (refDestructuringErrors) {
+      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
+        { refDestructuringErrors.parenthesizedAssign = start; }
+      if (refDestructuringErrors.parenthesizedBind < 0)
+        { refDestructuringErrors.parenthesizedBind = start; }
+    }
+    return expr
+
+  case types.bracketL:
+    node = this.startNode();
+    this.next();
+    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
+    return this.finishNode(node, "ArrayExpression")
+
+  case types.braceL:
+    return this.parseObj(false, refDestructuringErrors)
+
+  case types._function:
+    node = this.startNode();
+    this.next();
+    return this.parseFunction(node, 0)
+
+  case types._class:
+    return this.parseClass(this.startNode(), false)
+
+  case types._new:
+    return this.parseNew()
+
+  case types.backQuote:
+    return this.parseTemplate()
+
+  case types._import:
+    if (this.options.ecmaVersion > 10) {
+      return this.parseDynamicImport()
+    } else {
+      return this.unexpected()
+    }
+
+  default:
+    this.unexpected();
+  }
+};
+
+pp$3.parseDynamicImport = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.type !== types.parenL) {
+    this.unexpected();
+  }
+  return this.finishNode(node, "Import")
+};
+
+pp$3.parseLiteral = function(value) {
+  var node = this.startNode();
+  node.value = value;
+  node.raw = this.input.slice(this.start, this.end);
+  if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1); }
+  this.next();
+  return this.finishNode(node, "Literal")
+};
+
+pp$3.parseParenExpression = function() {
+  this.expect(types.parenL);
+  var val = this.parseExpression();
+  this.expect(types.parenR);
+  return val
+};
+
+pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
+  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
+  if (this.options.ecmaVersion >= 6) {
+    this.next();
+
+    var innerStartPos = this.start, innerStartLoc = this.startLoc;
+    var exprList = [], first = true, lastIsComma = false;
+    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    // Do not save awaitIdentPos to allow checking awaits nested in parameters
+    while (this.type !== types.parenR) {
+      first ? first = false : this.expect(types.comma);
+      if (allowTrailingComma && this.afterTrailingComma(types.parenR, true)) {
+        lastIsComma = true;
+        break
+      } else if (this.type === types.ellipsis) {
+        spreadStart = this.start;
+        exprList.push(this.parseParenItem(this.parseRestBinding()));
+        if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+        break
+      } else {
+        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));
+      }
+    }
+    var innerEndPos = this.start, innerEndLoc = this.startLoc;
+    this.expect(types.parenR);
+
+    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+      this.checkPatternErrors(refDestructuringErrors, false);
+      this.checkYieldAwaitInDefaultParams();
+      this.yieldPos = oldYieldPos;
+      this.awaitPos = oldAwaitPos;
+      return this.parseParenArrowList(startPos, startLoc, exprList)
+    }
+
+    if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
+    if (spreadStart) { this.unexpected(spreadStart); }
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    this.yieldPos = oldYieldPos || this.yieldPos;
+    this.awaitPos = oldAwaitPos || this.awaitPos;
+
+    if (exprList.length > 1) {
+      val = this.startNodeAt(innerStartPos, innerStartLoc);
+      val.expressions = exprList;
+      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
+    } else {
+      val = exprList[0];
+    }
+  } else {
+    val = this.parseParenExpression();
+  }
+
+  if (this.options.preserveParens) {
+    var par = this.startNodeAt(startPos, startLoc);
+    par.expression = val;
+    return this.finishNode(par, "ParenthesizedExpression")
+  } else {
+    return val
+  }
+};
+
+pp$3.parseParenItem = function(item) {
+  return item
+};
+
+pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
+  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
+};
+
+// New's precedence is slightly tricky. It must allow its argument to
+// be a `[]` or dot subscript expression, but not a call — at least,
+// not without wrapping it in parentheses. Thus, it uses the noCalls
+// argument to parseSubscripts to prevent it from consuming the
+// argument list.
+
+var empty$1 = [];
+
+pp$3.parseNew = function() {
+  var node = this.startNode();
+  var meta = this.parseIdent(true);
+  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
+    node.meta = meta;
+    var containsEsc = this.containsEsc;
+    node.property = this.parseIdent(true);
+    if (node.property.name !== "target" || containsEsc)
+      { this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target"); }
+    if (!this.inNonArrowFunction())
+      { this.raiseRecoverable(node.start, "new.target can only be used in functions"); }
+    return this.finishNode(node, "MetaProperty")
+  }
+  var startPos = this.start, startLoc = this.startLoc;
+  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
+  if (this.options.ecmaVersion > 10 && node.callee.type === "Import") {
+    this.raise(node.callee.start, "Cannot use new with import(...)");
+  }
+  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8 && node.callee.type !== "Import", false); }
+  else { node.arguments = empty$1; }
+  return this.finishNode(node, "NewExpression")
+};
+
+// Parse template expression.
+
+pp$3.parseTemplateElement = function(ref) {
+  var isTagged = ref.isTagged;
+
+  var elem = this.startNode();
+  if (this.type === types.invalidTemplate) {
+    if (!isTagged) {
+      this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
+    }
+    elem.value = {
+      raw: this.value,
+      cooked: null
+    };
+  } else {
+    elem.value = {
+      raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
+      cooked: this.value
+    };
+  }
+  this.next();
+  elem.tail = this.type === types.backQuote;
+  return this.finishNode(elem, "TemplateElement")
+};
+
+pp$3.parseTemplate = function(ref) {
+  if ( ref === void 0 ) ref = {};
+  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
+
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement({isTagged: isTagged});
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    if (this.type === types.eof) { this.raise(this.pos, "Unterminated template literal"); }
+    this.expect(types.dollarBraceL);
+    node.expressions.push(this.parseExpression());
+    this.expect(types.braceR);
+    node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged}));
+  }
+  this.next();
+  return this.finishNode(node, "TemplateLiteral")
+};
+
+pp$3.isAsyncProp = function(prop) {
+  return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
+    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
+    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+// Parse an object literal or binding pattern.
+
+pp$3.parseObj = function(isPattern, refDestructuringErrors) {
+  var node = this.startNode(), first = true, propHash = {};
+  node.properties = [];
+  this.next();
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (this.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
+
+    var prop = this.parseProperty(isPattern, refDestructuringErrors);
+    if (!isPattern) { this.checkPropClash(prop, propHash, refDestructuringErrors); }
+    node.properties.push(prop);
+  }
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
+};
+
+pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
+  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
+  if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
+    if (isPattern) {
+      prop.argument = this.parseIdent(false);
+      if (this.type === types.comma) {
+        this.raise(this.start, "Comma is not permitted after the rest element");
+      }
+      return this.finishNode(prop, "RestElement")
+    }
+    // To disallow parenthesized identifier via `this.toAssignable()`.
+    if (this.type === types.parenL && refDestructuringErrors) {
+      if (refDestructuringErrors.parenthesizedAssign < 0) {
+        refDestructuringErrors.parenthesizedAssign = this.start;
+      }
+      if (refDestructuringErrors.parenthesizedBind < 0) {
+        refDestructuringErrors.parenthesizedBind = this.start;
+      }
+    }
+    // Parse argument.
+    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+    // To disallow trailing comma via `this.toAssignable()`.
+    if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
+      refDestructuringErrors.trailingComma = this.start;
+    }
+    // Finish
+    return this.finishNode(prop, "SpreadElement")
+  }
+  if (this.options.ecmaVersion >= 6) {
+    prop.method = false;
+    prop.shorthand = false;
+    if (isPattern || refDestructuringErrors) {
+      startPos = this.start;
+      startLoc = this.startLoc;
+    }
+    if (!isPattern)
+      { isGenerator = this.eat(types.star); }
+  }
+  var containsEsc = this.containsEsc;
+  this.parsePropertyName(prop);
+  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
+    isAsync = true;
+    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+    this.parsePropertyName(prop, refDestructuringErrors);
+  } else {
+    isAsync = false;
+  }
+  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
+  return this.finishNode(prop, "Property")
+};
+
+pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
+  if ((isGenerator || isAsync) && this.type === types.colon)
+    { this.unexpected(); }
+
+  if (this.eat(types.colon)) {
+    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
+    prop.kind = "init";
+  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
+    if (isPattern) { this.unexpected(); }
+    prop.kind = "init";
+    prop.method = true;
+    prop.value = this.parseMethod(isGenerator, isAsync);
+  } else if (!isPattern && !containsEsc &&
+             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+             (prop.key.name === "get" || prop.key.name === "set") &&
+             (this.type !== types.comma && this.type !== types.braceR)) {
+    if (isGenerator || isAsync) { this.unexpected(); }
+    prop.kind = prop.key.name;
+    this.parsePropertyName(prop);
+    prop.value = this.parseMethod(false);
+    var paramCount = prop.kind === "get" ? 0 : 1;
+    if (prop.value.params.length !== paramCount) {
+      var start = prop.value.start;
+      if (prop.kind === "get")
+        { this.raiseRecoverable(start, "getter should have no params"); }
+      else
+        { this.raiseRecoverable(start, "setter should have exactly one param"); }
+    } else {
+      if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
+        { this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); }
+    }
+  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+    if (isGenerator || isAsync) { this.unexpected(); }
+    this.checkUnreserved(prop.key);
+    if (prop.key.name === "await" && !this.awaitIdentPos)
+      { this.awaitIdentPos = startPos; }
+    prop.kind = "init";
+    if (isPattern) {
+      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+    } else if (this.type === types.eq && refDestructuringErrors) {
+      if (refDestructuringErrors.shorthandAssign < 0)
+        { refDestructuringErrors.shorthandAssign = this.start; }
+      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+    } else {
+      prop.value = prop.key;
+    }
+    prop.shorthand = true;
+  } else { this.unexpected(); }
+};
+
+pp$3.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(types.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseMaybeAssign();
+      this.expect(types.bracketR);
+      return prop.key
+    } else {
+      prop.computed = false;
+    }
+  }
+  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never")
+};
+
+// Initialize empty function node.
+
+pp$3.initFunction = function(node) {
+  node.id = null;
+  if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; }
+  if (this.options.ecmaVersion >= 8) { node.async = false; }
+};
+
+// Parse object or class method.
+
+pp$3.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
+  var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6)
+    { node.generator = isGenerator; }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.awaitIdentPos = 0;
+  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
+
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+  this.parseFunctionBody(node, false, true);
+
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.awaitIdentPos = oldAwaitIdentPos;
+  return this.finishNode(node, "FunctionExpression")
+};
+
+// Parse arrow function expression with given parameters.
+
+pp$3.parseArrowExpression = function(node, params, isAsync) {
+  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+
+  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 8) { node.async = !!isAsync; }
+
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.awaitIdentPos = 0;
+
+  node.params = this.toAssignableList(params, true);
+  this.parseFunctionBody(node, true, false);
+
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.awaitIdentPos = oldAwaitIdentPos;
+  return this.finishNode(node, "ArrowFunctionExpression")
+};
+
+// Parse function body and check parameters.
+
+pp$3.parseFunctionBody = function(node, isArrowFunction, isMethod) {
+  var isExpression = isArrowFunction && this.type !== types.braceL;
+  var oldStrict = this.strict, useStrict = false;
+
+  if (isExpression) {
+    node.body = this.parseMaybeAssign();
+    node.expression = true;
+    this.checkParams(node, false);
+  } else {
+    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
+    if (!oldStrict || nonSimple) {
+      useStrict = this.strictDirective(this.end);
+      // If this is a strict mode function, verify that argument names
+      // are not repeated, and it does not try to bind the words `eval`
+      // or `arguments`.
+      if (useStrict && nonSimple)
+        { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
+    }
+    // Start a new scope with regard to labels and the `inFunction`
+    // flag (restore them to their old value afterwards).
+    var oldLabels = this.labels;
+    this.labels = [];
+    if (useStrict) { this.strict = true; }
+
+    // Add the params to varDeclaredNames to ensure that an error is thrown
+    // if a let/const declaration in the function clashes with one of the params.
+    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));
+    node.body = this.parseBlock(false);
+    node.expression = false;
+    this.adaptDirectivePrologue(node.body.body);
+    this.labels = oldLabels;
+  }
+  this.exitScope();
+
+  // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
+  if (this.strict && node.id) { this.checkLVal(node.id, BIND_OUTSIDE); }
+  this.strict = oldStrict;
+};
+
+pp$3.isSimpleParamList = function(params) {
+  for (var i = 0, list = params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    if (param.type !== "Identifier") { return false
+  } }
+  return true
+};
+
+// Checks function params for various disallowed patterns such as using "eval"
+// or "arguments" and duplicate parameters.
+
+pp$3.checkParams = function(node, allowDuplicates) {
+  var nameHash = {};
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash);
+  }
+};
+
+// Parses a comma-separated list of expressions, and returns them as
+// an array. `close` is the token type that ends the list, and
+// `allowEmpty` can be turned on to allow subsequent commas with
+// nothing in between them to be parsed as `null` (which is needed
+// for array literals).
+
+pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (allowTrailingComma && this.afterTrailingComma(close)) { break }
+    } else { first = false; }
+
+    var elt = (void 0);
+    if (allowEmpty && this.type === types.comma)
+      { elt = null; }
+    else if (this.type === types.ellipsis) {
+      elt = this.parseSpread(refDestructuringErrors);
+      if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)
+        { refDestructuringErrors.trailingComma = this.start; }
+    } else {
+      elt = this.parseMaybeAssign(false, refDestructuringErrors);
+    }
+    elts.push(elt);
+  }
+  return elts
+};
+
+pp$3.checkUnreserved = function(ref) {
+  var start = ref.start;
+  var end = ref.end;
+  var name = ref.name;
+
+  if (this.inGenerator && name === "yield")
+    { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); }
+  if (this.inAsync && name === "await")
+    { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); }
+  if (this.keywords.test(name))
+    { this.raise(start, ("Unexpected keyword '" + name + "'")); }
+  if (this.options.ecmaVersion < 6 &&
+    this.input.slice(start, end).indexOf("\\") !== -1) { return }
+  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
+  if (re.test(name)) {
+    if (!this.inAsync && name === "await")
+      { this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function"); }
+    this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved"));
+  }
+};
+
+// Parse the next token as an identifier. If `liberal` is true (used
+// when parsing properties), it will also convert keywords into
+// identifiers.
+
+pp$3.parseIdent = function(liberal, isBinding) {
+  var node = this.startNode();
+  if (this.type === types.name) {
+    node.name = this.value;
+  } else if (this.type.keyword) {
+    node.name = this.type.keyword;
+
+    // To fix https://github.com/acornjs/acorn/issues/575
+    // `class` and `function` keywords push new context into this.context.
+    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.
+    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword
+    if ((node.name === "class" || node.name === "function") &&
+        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
+      this.context.pop();
+    }
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  this.finishNode(node, "Identifier");
+  if (!liberal) {
+    this.checkUnreserved(node);
+    if (node.name === "await" && !this.awaitIdentPos)
+      { this.awaitIdentPos = node.start; }
+  }
+  return node
+};
+
+// Parses yield expression inside generator.
+
+pp$3.parseYield = function(noIn) {
+  if (!this.yieldPos) { this.yieldPos = this.start; }
+
+  var node = this.startNode();
+  this.next();
+  if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {
+    node.delegate = false;
+    node.argument = null;
+  } else {
+    node.delegate = this.eat(types.star);
+    node.argument = this.parseMaybeAssign(noIn);
+  }
+  return this.finishNode(node, "YieldExpression")
+};
+
+pp$3.parseAwait = function() {
+  if (!this.awaitPos) { this.awaitPos = this.start; }
+
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeUnary(null, true);
+  return this.finishNode(node, "AwaitExpression")
+};
+
+var pp$4 = Parser.prototype;
+
+// This function is used to raise exceptions on parse errors. It
+// takes an offset integer (into the current `input`) to indicate
+// the location of the error, attaches the position to the end
+// of the error message, and then raises a `SyntaxError` with that
+// message.
+
+pp$4.raise = function(pos, message) {
+  var loc = getLineInfo(this.input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+  throw err
+};
+
+pp$4.raiseRecoverable = pp$4.raise;
+
+pp$4.curPosition = function() {
+  if (this.options.locations) {
+    return new Position(this.curLine, this.pos - this.lineStart)
+  }
+};
+
+var pp$5 = Parser.prototype;
+
+var Scope = function Scope(flags) {
+  this.flags = flags;
+  // A list of var-declared names in the current lexical scope
+  this.var = [];
+  // A list of lexically-declared names in the current lexical scope
+  this.lexical = [];
+  // A list of lexically-declared FunctionDeclaration names in the current lexical scope
+  this.functions = [];
+};
+
+// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
+
+pp$5.enterScope = function(flags) {
+  this.scopeStack.push(new Scope(flags));
+};
+
+pp$5.exitScope = function() {
+  this.scopeStack.pop();
+};
+
+// The spec says:
+// > At the top level of a function, or script, function declarations are
+// > treated like var declarations rather than like lexical declarations.
+pp$5.treatFunctionsAsVarInScope = function(scope) {
+  return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)
+};
+
+pp$5.declareName = function(name, bindingType, pos) {
+  var redeclared = false;
+  if (bindingType === BIND_LEXICAL) {
+    var scope = this.currentScope();
+    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
+    scope.lexical.push(name);
+    if (this.inModule && (scope.flags & SCOPE_TOP))
+      { delete this.undefinedExports[name]; }
+  } else if (bindingType === BIND_SIMPLE_CATCH) {
+    var scope$1 = this.currentScope();
+    scope$1.lexical.push(name);
+  } else if (bindingType === BIND_FUNCTION) {
+    var scope$2 = this.currentScope();
+    if (this.treatFunctionsAsVar)
+      { redeclared = scope$2.lexical.indexOf(name) > -1; }
+    else
+      { redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; }
+    scope$2.functions.push(name);
+  } else {
+    for (var i = this.scopeStack.length - 1; i >= 0; --i) {
+      var scope$3 = this.scopeStack[i];
+      if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) ||
+          !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {
+        redeclared = true;
+        break
+      }
+      scope$3.var.push(name);
+      if (this.inModule && (scope$3.flags & SCOPE_TOP))
+        { delete this.undefinedExports[name]; }
+      if (scope$3.flags & SCOPE_VAR) { break }
+    }
+  }
+  if (redeclared) { this.raiseRecoverable(pos, ("Identifier '" + name + "' has already been declared")); }
+};
+
+pp$5.checkLocalExport = function(id) {
+  // scope.functions must be empty as Module code is always strict.
+  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&
+      this.scopeStack[0].var.indexOf(id.name) === -1) {
+    this.undefinedExports[id.name] = id;
+  }
+};
+
+pp$5.currentScope = function() {
+  return this.scopeStack[this.scopeStack.length - 1]
+};
+
+pp$5.currentVarScope = function() {
+  for (var i = this.scopeStack.length - 1;; i--) {
+    var scope = this.scopeStack[i];
+    if (scope.flags & SCOPE_VAR) { return scope }
+  }
+};
+
+// Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.
+pp$5.currentThisScope = function() {
+  for (var i = this.scopeStack.length - 1;; i--) {
+    var scope = this.scopeStack[i];
+    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }
+  }
+};
+
+var Node = function Node(parser, pos, loc) {
+  this.type = "";
+  this.start = pos;
+  this.end = 0;
+  if (parser.options.locations)
+    { this.loc = new SourceLocation(parser, loc); }
+  if (parser.options.directSourceFile)
+    { this.sourceFile = parser.options.directSourceFile; }
+  if (parser.options.ranges)
+    { this.range = [pos, 0]; }
+};
+
+// Start an AST node, attaching a start offset.
+
+var pp$6 = Parser.prototype;
+
+pp$6.startNode = function() {
+  return new Node(this, this.start, this.startLoc)
+};
+
+pp$6.startNodeAt = function(pos, loc) {
+  return new Node(this, pos, loc)
+};
+
+// Finish an AST node, adding `type` and `end` properties.
+
+function finishNodeAt(node, type, pos, loc) {
+  node.type = type;
+  node.end = pos;
+  if (this.options.locations)
+    { node.loc.end = loc; }
+  if (this.options.ranges)
+    { node.range[1] = pos; }
+  return node
+}
+
+pp$6.finishNode = function(node, type) {
+  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
+};
+
+// Finish node at given position
+
+pp$6.finishNodeAt = function(node, type, pos, loc) {
+  return finishNodeAt.call(this, node, type, pos, loc)
+};
+
+// The algorithm used to determine whether a regexp can appear at a
+
+var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
+  this.token = token;
+  this.isExpr = !!isExpr;
+  this.preserveSpace = !!preserveSpace;
+  this.override = override;
+  this.generator = !!generator;
+};
+
+var types$1 = {
+  b_stat: new TokContext("{", false),
+  b_expr: new TokContext("{", true),
+  b_tmpl: new TokContext("${", false),
+  p_stat: new TokContext("(", false),
+  p_expr: new TokContext("(", true),
+  q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }),
+  f_stat: new TokContext("function", false),
+  f_expr: new TokContext("function", true),
+  f_expr_gen: new TokContext("function", true, false, null, true),
+  f_gen: new TokContext("function", false, false, null, true)
+};
+
+var pp$7 = Parser.prototype;
+
+pp$7.initialContext = function() {
+  return [types$1.b_stat]
+};
+
+pp$7.braceIsBlock = function(prevType) {
+  var parent = this.curContext();
+  if (parent === types$1.f_expr || parent === types$1.f_stat)
+    { return true }
+  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
+    { return !parent.isExpr }
+
+  // The check for `tt.name && exprAllowed` detects whether we are
+  // after a `yield` or `of` construct. See the `updateContext` for
+  // `tt.name`.
+  if (prevType === types._return || prevType === types.name && this.exprAllowed)
+    { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
+  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)
+    { return true }
+  if (prevType === types.braceL)
+    { return parent === types$1.b_stat }
+  if (prevType === types._var || prevType === types._const || prevType === types.name)
+    { return false }
+  return !this.exprAllowed
+};
+
+pp$7.inGeneratorContext = function() {
+  for (var i = this.context.length - 1; i >= 1; i--) {
+    var context = this.context[i];
+    if (context.token === "function")
+      { return context.generator }
+  }
+  return false
+};
+
+pp$7.updateContext = function(prevType) {
+  var update, type = this.type;
+  if (type.keyword && prevType === types.dot)
+    { this.exprAllowed = false; }
+  else if (update = type.updateContext)
+    { update.call(this, prevType); }
+  else
+    { this.exprAllowed = type.beforeExpr; }
+};
+
+// Token-specific context update code
+
+types.parenR.updateContext = types.braceR.updateContext = function() {
+  if (this.context.length === 1) {
+    this.exprAllowed = true;
+    return
+  }
+  var out = this.context.pop();
+  if (out === types$1.b_stat && this.curContext().token === "function") {
+    out = this.context.pop();
+  }
+  this.exprAllowed = !out.isExpr;
+};
+
+types.braceL.updateContext = function(prevType) {
+  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
+  this.exprAllowed = true;
+};
+
+types.dollarBraceL.updateContext = function() {
+  this.context.push(types$1.b_tmpl);
+  this.exprAllowed = true;
+};
+
+types.parenL.updateContext = function(prevType) {
+  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
+  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
+  this.exprAllowed = true;
+};
+
+types.incDec.updateContext = function() {
+  // tokExprAllowed stays unchanged
+};
+
+types._function.updateContext = types._class.updateContext = function(prevType) {
+  if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
+      !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&
+      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
+    { this.context.push(types$1.f_expr); }
+  else
+    { this.context.push(types$1.f_stat); }
+  this.exprAllowed = false;
+};
+
+types.backQuote.updateContext = function() {
+  if (this.curContext() === types$1.q_tmpl)
+    { this.context.pop(); }
+  else
+    { this.context.push(types$1.q_tmpl); }
+  this.exprAllowed = false;
+};
+
+types.star.updateContext = function(prevType) {
+  if (prevType === types._function) {
+    var index = this.context.length - 1;
+    if (this.context[index] === types$1.f_expr)
+      { this.context[index] = types$1.f_expr_gen; }
+    else
+      { this.context[index] = types$1.f_gen; }
+  }
+  this.exprAllowed = true;
+};
+
+types.name.updateContext = function(prevType) {
+  var allowed = false;
+  if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {
+    if (this.value === "of" && !this.exprAllowed ||
+        this.value === "yield" && this.inGeneratorContext())
+      { allowed = true; }
+  }
+  this.exprAllowed = allowed;
+};
+
+// This file contains Unicode properties extracted from the ECMAScript
+// specification. The lists are extracted like so:
+// $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)
+
+// #table-binary-unicode-properties
+var ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
+var ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic";
+var ecma11BinaryProperties = ecma10BinaryProperties;
+var unicodeBinaryProperties = {
+  9: ecma9BinaryProperties,
+  10: ecma10BinaryProperties,
+  11: ecma11BinaryProperties
+};
+
+// #table-unicode-general-category-values
+var unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu";
+
+// #table-unicode-script-values
+var ecma9ScriptValues = "Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
+var ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
+var ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
+var unicodeScriptValues = {
+  9: ecma9ScriptValues,
+  10: ecma10ScriptValues,
+  11: ecma11ScriptValues
+};
+
+var data = {};
+function buildUnicodeData(ecmaVersion) {
+  var d = data[ecmaVersion] = {
+    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues),
+    nonBinary: {
+      General_Category: wordsRegexp(unicodeGeneralCategoryValues),
+      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])
+    }
+  };
+  d.nonBinary.Script_Extensions = d.nonBinary.Script;
+
+  d.nonBinary.gc = d.nonBinary.General_Category;
+  d.nonBinary.sc = d.nonBinary.Script;
+  d.nonBinary.scx = d.nonBinary.Script_Extensions;
+}
+buildUnicodeData(9);
+buildUnicodeData(10);
+buildUnicodeData(11);
+
+var pp$8 = Parser.prototype;
+
+var RegExpValidationState = function RegExpValidationState(parser) {
+  this.parser = parser;
+  this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
+  this.unicodeProperties = data[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];
+  this.source = "";
+  this.flags = "";
+  this.start = 0;
+  this.switchU = false;
+  this.switchN = false;
+  this.pos = 0;
+  this.lastIntValue = 0;
+  this.lastStringValue = "";
+  this.lastAssertionIsQuantifiable = false;
+  this.numCapturingParens = 0;
+  this.maxBackReference = 0;
+  this.groupNames = [];
+  this.backReferenceNames = [];
+};
+
+RegExpValidationState.prototype.reset = function reset (start, pattern, flags) {
+  var unicode = flags.indexOf("u") !== -1;
+  this.start = start | 0;
+  this.source = pattern + "";
+  this.flags = flags;
+  this.switchU = unicode && this.parser.options.ecmaVersion >= 6;
+  this.switchN = unicode && this.parser.options.ecmaVersion >= 9;
+};
+
+RegExpValidationState.prototype.raise = function raise (message) {
+  this.parser.raiseRecoverable(this.start, ("Invalid regular expression: /" + (this.source) + "/: " + message));
+};
+
+// If u flag is given, this returns the code point at the index (it combines a surrogate pair).
+// Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).
+RegExpValidationState.prototype.at = function at (i) {
+  var s = this.source;
+  var l = s.length;
+  if (i >= l) {
+    return -1
+  }
+  var c = s.charCodeAt(i);
+  if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
+    return c
+  }
+  var next = s.charCodeAt(i + 1);
+  return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c
+};
+
+RegExpValidationState.prototype.nextIndex = function nextIndex (i) {
+  var s = this.source;
+  var l = s.length;
+  if (i >= l) {
+    return l
+  }
+  var c = s.charCodeAt(i), next;
+  if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||
+      (next = s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) {
+    return i + 1
+  }
+  return i + 2
+};
+
+RegExpValidationState.prototype.current = function current () {
+  return this.at(this.pos)
+};
+
+RegExpValidationState.prototype.lookahead = function lookahead () {
+  return this.at(this.nextIndex(this.pos))
+};
+
+RegExpValidationState.prototype.advance = function advance () {
+  this.pos = this.nextIndex(this.pos);
+};
+
+RegExpValidationState.prototype.eat = function eat (ch) {
+  if (this.current() === ch) {
+    this.advance();
+    return true
+  }
+  return false
+};
+
+function codePointToString(ch) {
+  if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
+  ch -= 0x10000;
+  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)
+}
+
+/**
+ * Validate the flags part of a given RegExpLiteral.
+ *
+ * @param {RegExpValidationState} state The state to validate RegExp.
+ * @returns {void}
+ */
+pp$8.validateRegExpFlags = function(state) {
+  var validFlags = state.validFlags;
+  var flags = state.flags;
+
+  for (var i = 0; i < flags.length; i++) {
+    var flag = flags.charAt(i);
+    if (validFlags.indexOf(flag) === -1) {
+      this.raise(state.start, "Invalid regular expression flag");
+    }
+    if (flags.indexOf(flag, i + 1) > -1) {
+      this.raise(state.start, "Duplicate regular expression flag");
+    }
+  }
+};
+
+/**
+ * Validate the pattern part of a given RegExpLiteral.
+ *
+ * @param {RegExpValidationState} state The state to validate RegExp.
+ * @returns {void}
+ */
+pp$8.validateRegExpPattern = function(state) {
+  this.regexp_pattern(state);
+
+  // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of
+  // parsing contains a |GroupName|, reparse with the goal symbol
+  // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*
+  // exception if _P_ did not conform to the grammar, if any elements of _P_
+  // were not matched by the parse, or if any Early Error conditions exist.
+  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
+    state.switchN = true;
+    this.regexp_pattern(state);
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern
+pp$8.regexp_pattern = function(state) {
+  state.pos = 0;
+  state.lastIntValue = 0;
+  state.lastStringValue = "";
+  state.lastAssertionIsQuantifiable = false;
+  state.numCapturingParens = 0;
+  state.maxBackReference = 0;
+  state.groupNames.length = 0;
+  state.backReferenceNames.length = 0;
+
+  this.regexp_disjunction(state);
+
+  if (state.pos !== state.source.length) {
+    // Make the same messages as V8.
+    if (state.eat(0x29 /* ) */)) {
+      state.raise("Unmatched ')'");
+    }
+    if (state.eat(0x5D /* [ */) || state.eat(0x7D /* } */)) {
+      state.raise("Lone quantifier brackets");
+    }
+  }
+  if (state.maxBackReference > state.numCapturingParens) {
+    state.raise("Invalid escape");
+  }
+  for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
+    var name = list[i];
+
+    if (state.groupNames.indexOf(name) === -1) {
+      state.raise("Invalid named capture referenced");
+    }
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction
+pp$8.regexp_disjunction = function(state) {
+  this.regexp_alternative(state);
+  while (state.eat(0x7C /* | */)) {
+    this.regexp_alternative(state);
+  }
+
+  // Make the same message as V8.
+  if (this.regexp_eatQuantifier(state, true)) {
+    state.raise("Nothing to repeat");
+  }
+  if (state.eat(0x7B /* { */)) {
+    state.raise("Lone quantifier brackets");
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative
+pp$8.regexp_alternative = function(state) {
+  while (state.pos < state.source.length && this.regexp_eatTerm(state))
+    { }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term
+pp$8.regexp_eatTerm = function(state) {
+  if (this.regexp_eatAssertion(state)) {
+    // Handle `QuantifiableAssertion Quantifier` alternative.
+    // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion
+    // is a QuantifiableAssertion.
+    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
+      // Make the same message as V8.
+      if (state.switchU) {
+        state.raise("Invalid quantifier");
+      }
+    }
+    return true
+  }
+
+  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
+    this.regexp_eatQuantifier(state);
+    return true
+  }
+
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion
+pp$8.regexp_eatAssertion = function(state) {
+  var start = state.pos;
+  state.lastAssertionIsQuantifiable = false;
+
+  // ^, $
+  if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {
+    return true
+  }
+
+  // \b \B
+  if (state.eat(0x5C /* \ */)) {
+    if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {
+      return true
+    }
+    state.pos = start;
+  }
+
+  // Lookahead / Lookbehind
+  if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {
+    var lookbehind = false;
+    if (this.options.ecmaVersion >= 9) {
+      lookbehind = state.eat(0x3C /* < */);
+    }
+    if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {
+      this.regexp_disjunction(state);
+      if (!state.eat(0x29 /* ) */)) {
+        state.raise("Unterminated group");
+      }
+      state.lastAssertionIsQuantifiable = !lookbehind;
+      return true
+    }
+  }
+
+  state.pos = start;
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier
+pp$8.regexp_eatQuantifier = function(state, noError) {
+  if ( noError === void 0 ) noError = false;
+
+  if (this.regexp_eatQuantifierPrefix(state, noError)) {
+    state.eat(0x3F /* ? */);
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix
+pp$8.regexp_eatQuantifierPrefix = function(state, noError) {
+  return (
+    state.eat(0x2A /* * */) ||
+    state.eat(0x2B /* + */) ||
+    state.eat(0x3F /* ? */) ||
+    this.regexp_eatBracedQuantifier(state, noError)
+  )
+};
+pp$8.regexp_eatBracedQuantifier = function(state, noError) {
+  var start = state.pos;
+  if (state.eat(0x7B /* { */)) {
+    var min = 0, max = -1;
+    if (this.regexp_eatDecimalDigits(state)) {
+      min = state.lastIntValue;
+      if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {
+        max = state.lastIntValue;
+      }
+      if (state.eat(0x7D /* } */)) {
+        // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term
+        if (max !== -1 && max < min && !noError) {
+          state.raise("numbers out of order in {} quantifier");
+        }
+        return true
+      }
+    }
+    if (state.switchU && !noError) {
+      state.raise("Incomplete quantifier");
+    }
+    state.pos = start;
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom
+pp$8.regexp_eatAtom = function(state) {
+  return (
+    this.regexp_eatPatternCharacters(state) ||
+    state.eat(0x2E /* . */) ||
+    this.regexp_eatReverseSolidusAtomEscape(state) ||
+    this.regexp_eatCharacterClass(state) ||
+    this.regexp_eatUncapturingGroup(state) ||
+    this.regexp_eatCapturingGroup(state)
+  )
+};
+pp$8.regexp_eatReverseSolidusAtomEscape = function(state) {
+  var start = state.pos;
+  if (state.eat(0x5C /* \ */)) {
+    if (this.regexp_eatAtomEscape(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatUncapturingGroup = function(state) {
+  var start = state.pos;
+  if (state.eat(0x28 /* ( */)) {
+    if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {
+      this.regexp_disjunction(state);
+      if (state.eat(0x29 /* ) */)) {
+        return true
+      }
+      state.raise("Unterminated group");
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatCapturingGroup = function(state) {
+  if (state.eat(0x28 /* ( */)) {
+    if (this.options.ecmaVersion >= 9) {
+      this.regexp_groupSpecifier(state);
+    } else if (state.current() === 0x3F /* ? */) {
+      state.raise("Invalid group");
+    }
+    this.regexp_disjunction(state);
+    if (state.eat(0x29 /* ) */)) {
+      state.numCapturingParens += 1;
+      return true
+    }
+    state.raise("Unterminated group");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom
+pp$8.regexp_eatExtendedAtom = function(state) {
+  return (
+    state.eat(0x2E /* . */) ||
+    this.regexp_eatReverseSolidusAtomEscape(state) ||
+    this.regexp_eatCharacterClass(state) ||
+    this.regexp_eatUncapturingGroup(state) ||
+    this.regexp_eatCapturingGroup(state) ||
+    this.regexp_eatInvalidBracedQuantifier(state) ||
+    this.regexp_eatExtendedPatternCharacter(state)
+  )
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier
+pp$8.regexp_eatInvalidBracedQuantifier = function(state) {
+  if (this.regexp_eatBracedQuantifier(state, true)) {
+    state.raise("Nothing to repeat");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter
+pp$8.regexp_eatSyntaxCharacter = function(state) {
+  var ch = state.current();
+  if (isSyntaxCharacter(ch)) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+  return false
+};
+function isSyntaxCharacter(ch) {
+  return (
+    ch === 0x24 /* $ */ ||
+    ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||
+    ch === 0x2E /* . */ ||
+    ch === 0x3F /* ? */ ||
+    ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||
+    ch >= 0x7B /* { */ && ch <= 0x7D /* } */
+  )
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter
+// But eat eager.
+pp$8.regexp_eatPatternCharacters = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
+    state.advance();
+  }
+  return state.pos !== start
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter
+pp$8.regexp_eatExtendedPatternCharacter = function(state) {
+  var ch = state.current();
+  if (
+    ch !== -1 &&
+    ch !== 0x24 /* $ */ &&
+    !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&
+    ch !== 0x2E /* . */ &&
+    ch !== 0x3F /* ? */ &&
+    ch !== 0x5B /* [ */ &&
+    ch !== 0x5E /* ^ */ &&
+    ch !== 0x7C /* | */
+  ) {
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// GroupSpecifier[U] ::
+//   [empty]
+//   `?` GroupName[?U]
+pp$8.regexp_groupSpecifier = function(state) {
+  if (state.eat(0x3F /* ? */)) {
+    if (this.regexp_eatGroupName(state)) {
+      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
+        state.raise("Duplicate capture group name");
+      }
+      state.groupNames.push(state.lastStringValue);
+      return
+    }
+    state.raise("Invalid group");
+  }
+};
+
+// GroupName[U] ::
+//   `<` RegExpIdentifierName[?U] `>`
+// Note: this updates `state.lastStringValue` property with the eaten name.
+pp$8.regexp_eatGroupName = function(state) {
+  state.lastStringValue = "";
+  if (state.eat(0x3C /* < */)) {
+    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {
+      return true
+    }
+    state.raise("Invalid capture group name");
+  }
+  return false
+};
+
+// RegExpIdentifierName[U] ::
+//   RegExpIdentifierStart[?U]
+//   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]
+// Note: this updates `state.lastStringValue` property with the eaten name.
+pp$8.regexp_eatRegExpIdentifierName = function(state) {
+  state.lastStringValue = "";
+  if (this.regexp_eatRegExpIdentifierStart(state)) {
+    state.lastStringValue += codePointToString(state.lastIntValue);
+    while (this.regexp_eatRegExpIdentifierPart(state)) {
+      state.lastStringValue += codePointToString(state.lastIntValue);
+    }
+    return true
+  }
+  return false
+};
+
+// RegExpIdentifierStart[U] ::
+//   UnicodeIDStart
+//   `$`
+//   `_`
+//   `\` RegExpUnicodeEscapeSequence[?U]
+pp$8.regexp_eatRegExpIdentifierStart = function(state) {
+  var start = state.pos;
+  var ch = state.current();
+  state.advance();
+
+  if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+    ch = state.lastIntValue;
+  }
+  if (isRegExpIdentifierStart(ch)) {
+    state.lastIntValue = ch;
+    return true
+  }
+
+  state.pos = start;
+  return false
+};
+function isRegExpIdentifierStart(ch) {
+  return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */
+}
+
+// RegExpIdentifierPart[U] ::
+//   UnicodeIDContinue
+//   `$`
+//   `_`
+//   `\` RegExpUnicodeEscapeSequence[?U]
+//   <ZWNJ>
+//   <ZWJ>
+pp$8.regexp_eatRegExpIdentifierPart = function(state) {
+  var start = state.pos;
+  var ch = state.current();
+  state.advance();
+
+  if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+    ch = state.lastIntValue;
+  }
+  if (isRegExpIdentifierPart(ch)) {
+    state.lastIntValue = ch;
+    return true
+  }
+
+  state.pos = start;
+  return false
+};
+function isRegExpIdentifierPart(ch) {
+  return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape
+pp$8.regexp_eatAtomEscape = function(state) {
+  if (
+    this.regexp_eatBackReference(state) ||
+    this.regexp_eatCharacterClassEscape(state) ||
+    this.regexp_eatCharacterEscape(state) ||
+    (state.switchN && this.regexp_eatKGroupName(state))
+  ) {
+    return true
+  }
+  if (state.switchU) {
+    // Make the same message as V8.
+    if (state.current() === 0x63 /* c */) {
+      state.raise("Invalid unicode escape");
+    }
+    state.raise("Invalid escape");
+  }
+  return false
+};
+pp$8.regexp_eatBackReference = function(state) {
+  var start = state.pos;
+  if (this.regexp_eatDecimalEscape(state)) {
+    var n = state.lastIntValue;
+    if (state.switchU) {
+      // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape
+      if (n > state.maxBackReference) {
+        state.maxBackReference = n;
+      }
+      return true
+    }
+    if (n <= state.numCapturingParens) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatKGroupName = function(state) {
+  if (state.eat(0x6B /* k */)) {
+    if (this.regexp_eatGroupName(state)) {
+      state.backReferenceNames.push(state.lastStringValue);
+      return true
+    }
+    state.raise("Invalid named reference");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape
+pp$8.regexp_eatCharacterEscape = function(state) {
+  return (
+    this.regexp_eatControlEscape(state) ||
+    this.regexp_eatCControlLetter(state) ||
+    this.regexp_eatZero(state) ||
+    this.regexp_eatHexEscapeSequence(state) ||
+    this.regexp_eatRegExpUnicodeEscapeSequence(state) ||
+    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
+    this.regexp_eatIdentityEscape(state)
+  )
+};
+pp$8.regexp_eatCControlLetter = function(state) {
+  var start = state.pos;
+  if (state.eat(0x63 /* c */)) {
+    if (this.regexp_eatControlLetter(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatZero = function(state) {
+  if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {
+    state.lastIntValue = 0;
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape
+pp$8.regexp_eatControlEscape = function(state) {
+  var ch = state.current();
+  if (ch === 0x74 /* t */) {
+    state.lastIntValue = 0x09; /* \t */
+    state.advance();
+    return true
+  }
+  if (ch === 0x6E /* n */) {
+    state.lastIntValue = 0x0A; /* \n */
+    state.advance();
+    return true
+  }
+  if (ch === 0x76 /* v */) {
+    state.lastIntValue = 0x0B; /* \v */
+    state.advance();
+    return true
+  }
+  if (ch === 0x66 /* f */) {
+    state.lastIntValue = 0x0C; /* \f */
+    state.advance();
+    return true
+  }
+  if (ch === 0x72 /* r */) {
+    state.lastIntValue = 0x0D; /* \r */
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter
+pp$8.regexp_eatControlLetter = function(state) {
+  var ch = state.current();
+  if (isControlLetter(ch)) {
+    state.lastIntValue = ch % 0x20;
+    state.advance();
+    return true
+  }
+  return false
+};
+function isControlLetter(ch) {
+  return (
+    (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||
+    (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)
+  )
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence
+pp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x75 /* u */)) {
+    if (this.regexp_eatFixedHexDigits(state, 4)) {
+      var lead = state.lastIntValue;
+      if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {
+        var leadSurrogateEnd = state.pos;
+        if (state.eat(0x5C /* \ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {
+          var trail = state.lastIntValue;
+          if (trail >= 0xDC00 && trail <= 0xDFFF) {
+            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+            return true
+          }
+        }
+        state.pos = leadSurrogateEnd;
+        state.lastIntValue = lead;
+      }
+      return true
+    }
+    if (
+      state.switchU &&
+      state.eat(0x7B /* { */) &&
+      this.regexp_eatHexDigits(state) &&
+      state.eat(0x7D /* } */) &&
+      isValidUnicode(state.lastIntValue)
+    ) {
+      return true
+    }
+    if (state.switchU) {
+      state.raise("Invalid unicode escape");
+    }
+    state.pos = start;
+  }
+
+  return false
+};
+function isValidUnicode(ch) {
+  return ch >= 0 && ch <= 0x10FFFF
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape
+pp$8.regexp_eatIdentityEscape = function(state) {
+  if (state.switchU) {
+    if (this.regexp_eatSyntaxCharacter(state)) {
+      return true
+    }
+    if (state.eat(0x2F /* / */)) {
+      state.lastIntValue = 0x2F; /* / */
+      return true
+    }
+    return false
+  }
+
+  var ch = state.current();
+  if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape
+pp$8.regexp_eatDecimalEscape = function(state) {
+  state.lastIntValue = 0;
+  var ch = state.current();
+  if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {
+    do {
+      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+      state.advance();
+    } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape
+pp$8.regexp_eatCharacterClassEscape = function(state) {
+  var ch = state.current();
+
+  if (isCharacterClassEscape(ch)) {
+    state.lastIntValue = -1;
+    state.advance();
+    return true
+  }
+
+  if (
+    state.switchU &&
+    this.options.ecmaVersion >= 9 &&
+    (ch === 0x50 /* P */ || ch === 0x70 /* p */)
+  ) {
+    state.lastIntValue = -1;
+    state.advance();
+    if (
+      state.eat(0x7B /* { */) &&
+      this.regexp_eatUnicodePropertyValueExpression(state) &&
+      state.eat(0x7D /* } */)
+    ) {
+      return true
+    }
+    state.raise("Invalid property name");
+  }
+
+  return false
+};
+function isCharacterClassEscape(ch) {
+  return (
+    ch === 0x64 /* d */ ||
+    ch === 0x44 /* D */ ||
+    ch === 0x73 /* s */ ||
+    ch === 0x53 /* S */ ||
+    ch === 0x77 /* w */ ||
+    ch === 0x57 /* W */
+  )
+}
+
+// UnicodePropertyValueExpression ::
+//   UnicodePropertyName `=` UnicodePropertyValue
+//   LoneUnicodePropertyNameOrValue
+pp$8.regexp_eatUnicodePropertyValueExpression = function(state) {
+  var start = state.pos;
+
+  // UnicodePropertyName `=` UnicodePropertyValue
+  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {
+    var name = state.lastStringValue;
+    if (this.regexp_eatUnicodePropertyValue(state)) {
+      var value = state.lastStringValue;
+      this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
+      return true
+    }
+  }
+  state.pos = start;
+
+  // LoneUnicodePropertyNameOrValue
+  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
+    var nameOrValue = state.lastStringValue;
+    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
+    return true
+  }
+  return false
+};
+pp$8.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+  if (!has(state.unicodeProperties.nonBinary, name))
+    { state.raise("Invalid property name"); }
+  if (!state.unicodeProperties.nonBinary[name].test(value))
+    { state.raise("Invalid property value"); }
+};
+pp$8.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
+  if (!state.unicodeProperties.binary.test(nameOrValue))
+    { state.raise("Invalid property name"); }
+};
+
+// UnicodePropertyName ::
+//   UnicodePropertyNameCharacters
+pp$8.regexp_eatUnicodePropertyName = function(state) {
+  var ch = 0;
+  state.lastStringValue = "";
+  while (isUnicodePropertyNameCharacter(ch = state.current())) {
+    state.lastStringValue += codePointToString(ch);
+    state.advance();
+  }
+  return state.lastStringValue !== ""
+};
+function isUnicodePropertyNameCharacter(ch) {
+  return isControlLetter(ch) || ch === 0x5F /* _ */
+}
+
+// UnicodePropertyValue ::
+//   UnicodePropertyValueCharacters
+pp$8.regexp_eatUnicodePropertyValue = function(state) {
+  var ch = 0;
+  state.lastStringValue = "";
+  while (isUnicodePropertyValueCharacter(ch = state.current())) {
+    state.lastStringValue += codePointToString(ch);
+    state.advance();
+  }
+  return state.lastStringValue !== ""
+};
+function isUnicodePropertyValueCharacter(ch) {
+  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)
+}
+
+// LoneUnicodePropertyNameOrValue ::
+//   UnicodePropertyValueCharacters
+pp$8.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
+  return this.regexp_eatUnicodePropertyValue(state)
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass
+pp$8.regexp_eatCharacterClass = function(state) {
+  if (state.eat(0x5B /* [ */)) {
+    state.eat(0x5E /* ^ */);
+    this.regexp_classRanges(state);
+    if (state.eat(0x5D /* [ */)) {
+      return true
+    }
+    // Unreachable since it threw "unterminated regular expression" error before.
+    state.raise("Unterminated character class");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges
+// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges
+// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash
+pp$8.regexp_classRanges = function(state) {
+  while (this.regexp_eatClassAtom(state)) {
+    var left = state.lastIntValue;
+    if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {
+      var right = state.lastIntValue;
+      if (state.switchU && (left === -1 || right === -1)) {
+        state.raise("Invalid character class");
+      }
+      if (left !== -1 && right !== -1 && left > right) {
+        state.raise("Range out of order in character class");
+      }
+    }
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash
+pp$8.regexp_eatClassAtom = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x5C /* \ */)) {
+    if (this.regexp_eatClassEscape(state)) {
+      return true
+    }
+    if (state.switchU) {
+      // Make the same message as V8.
+      var ch$1 = state.current();
+      if (ch$1 === 0x63 /* c */ || isOctalDigit(ch$1)) {
+        state.raise("Invalid class escape");
+      }
+      state.raise("Invalid escape");
+    }
+    state.pos = start;
+  }
+
+  var ch = state.current();
+  if (ch !== 0x5D /* [ */) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape
+pp$8.regexp_eatClassEscape = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x62 /* b */)) {
+    state.lastIntValue = 0x08; /* <BS> */
+    return true
+  }
+
+  if (state.switchU && state.eat(0x2D /* - */)) {
+    state.lastIntValue = 0x2D; /* - */
+    return true
+  }
+
+  if (!state.switchU && state.eat(0x63 /* c */)) {
+    if (this.regexp_eatClassControlLetter(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+
+  return (
+    this.regexp_eatCharacterClassEscape(state) ||
+    this.regexp_eatCharacterEscape(state)
+  )
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter
+pp$8.regexp_eatClassControlLetter = function(state) {
+  var ch = state.current();
+  if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {
+    state.lastIntValue = ch % 0x20;
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+pp$8.regexp_eatHexEscapeSequence = function(state) {
+  var start = state.pos;
+  if (state.eat(0x78 /* x */)) {
+    if (this.regexp_eatFixedHexDigits(state, 2)) {
+      return true
+    }
+    if (state.switchU) {
+      state.raise("Invalid escape");
+    }
+    state.pos = start;
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits
+pp$8.regexp_eatDecimalDigits = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  state.lastIntValue = 0;
+  while (isDecimalDigit(ch = state.current())) {
+    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+    state.advance();
+  }
+  return state.pos !== start
+};
+function isDecimalDigit(ch) {
+  return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits
+pp$8.regexp_eatHexDigits = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  state.lastIntValue = 0;
+  while (isHexDigit(ch = state.current())) {
+    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+    state.advance();
+  }
+  return state.pos !== start
+};
+function isHexDigit(ch) {
+  return (
+    (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||
+    (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||
+    (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)
+  )
+}
+function hexToInt(ch) {
+  if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {
+    return 10 + (ch - 0x41 /* A */)
+  }
+  if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {
+    return 10 + (ch - 0x61 /* a */)
+  }
+  return ch - 0x30 /* 0 */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence
+// Allows only 0-377(octal) i.e. 0-255(decimal).
+pp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {
+  if (this.regexp_eatOctalDigit(state)) {
+    var n1 = state.lastIntValue;
+    if (this.regexp_eatOctalDigit(state)) {
+      var n2 = state.lastIntValue;
+      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
+        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
+      } else {
+        state.lastIntValue = n1 * 8 + n2;
+      }
+    } else {
+      state.lastIntValue = n1;
+    }
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit
+pp$8.regexp_eatOctalDigit = function(state) {
+  var ch = state.current();
+  if (isOctalDigit(ch)) {
+    state.lastIntValue = ch - 0x30; /* 0 */
+    state.advance();
+    return true
+  }
+  state.lastIntValue = 0;
+  return false
+};
+function isOctalDigit(ch) {
+  return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits
+// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit
+// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+pp$8.regexp_eatFixedHexDigits = function(state, length) {
+  var start = state.pos;
+  state.lastIntValue = 0;
+  for (var i = 0; i < length; ++i) {
+    var ch = state.current();
+    if (!isHexDigit(ch)) {
+      state.pos = start;
+      return false
+    }
+    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+    state.advance();
+  }
+  return true
+};
+
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
+
+var Token = function Token(p) {
+  this.type = p.type;
+  this.value = p.value;
+  this.start = p.start;
+  this.end = p.end;
+  if (p.options.locations)
+    { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
+  if (p.options.ranges)
+    { this.range = [p.start, p.end]; }
+};
+
+// ## Tokenizer
+
+var pp$9 = Parser.prototype;
+
+// Move to the next token
+
+pp$9.next = function() {
+  if (this.options.onToken)
+    { this.options.onToken(new Token(this)); }
+
+  this.lastTokEnd = this.end;
+  this.lastTokStart = this.start;
+  this.lastTokEndLoc = this.endLoc;
+  this.lastTokStartLoc = this.startLoc;
+  this.nextToken();
+};
+
+pp$9.getToken = function() {
+  this.next();
+  return new Token(this)
+};
+
+// If we're in an ES6 environment, make parsers iterable
+if (typeof Symbol !== "undefined")
+  { pp$9[Symbol.iterator] = function() {
+    var this$1 = this;
+
+    return {
+      next: function () {
+        var token = this$1.getToken();
+        return {
+          done: token.type === types.eof,
+          value: token
+        }
+      }
+    }
+  }; }
+
+// Toggle strict mode. Re-reads the next number or string to please
+// pedantic tests (`"use strict"; 010;` should fail).
+
+pp$9.curContext = function() {
+  return this.context[this.context.length - 1]
+};
+
+// Read a single token, updating the parser object's token-related
+// properties.
+
+pp$9.nextToken = function() {
+  var curContext = this.curContext();
+  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
+
+  this.start = this.pos;
+  if (this.options.locations) { this.startLoc = this.curPosition(); }
+  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+
+  if (curContext.override) { return curContext.override(this) }
+  else { this.readToken(this.fullCharCodeAtPos()); }
+};
+
+pp$9.readToken = function(code) {
+  // Identifier or keyword. '\uXXXX' sequences are allowed in
+  // identifiers, so '\' also dispatches to that.
+  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+    { return this.readWord() }
+
+  return this.getTokenFromCode(code)
+};
+
+pp$9.fullCharCodeAtPos = function() {
+  var code = this.input.charCodeAt(this.pos);
+  if (code <= 0xd7ff || code >= 0xe000) { return code }
+  var next = this.input.charCodeAt(this.pos + 1);
+  return (code << 10) + next - 0x35fdc00
+};
+
+pp$9.skipBlockComment = function() {
+  var startLoc = this.options.onComment && this.curPosition();
+  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+  if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
+  this.pos = end + 2;
+  if (this.options.locations) {
+    lineBreakG.lastIndex = start;
+    var match;
+    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
+      ++this.curLine;
+      this.lineStart = match.index + match[0].length;
+    }
+  }
+  if (this.options.onComment)
+    { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                           startLoc, this.curPosition()); }
+};
+
+pp$9.skipLineComment = function(startSkip) {
+  var start = this.pos;
+  var startLoc = this.options.onComment && this.curPosition();
+  var ch = this.input.charCodeAt(this.pos += startSkip);
+  while (this.pos < this.input.length && !isNewLine(ch)) {
+    ch = this.input.charCodeAt(++this.pos);
+  }
+  if (this.options.onComment)
+    { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                           startLoc, this.curPosition()); }
+};
+
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments, and.
+
+pp$9.skipSpace = function() {
+  loop: while (this.pos < this.input.length) {
+    var ch = this.input.charCodeAt(this.pos);
+    switch (ch) {
+    case 32: case 160: // ' '
+      ++this.pos;
+      break
+    case 13:
+      if (this.input.charCodeAt(this.pos + 1) === 10) {
+        ++this.pos;
+      }
+    case 10: case 8232: case 8233:
+      ++this.pos;
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      break
+    case 47: // '/'
+      switch (this.input.charCodeAt(this.pos + 1)) {
+      case 42: // '*'
+        this.skipBlockComment();
+        break
+      case 47:
+        this.skipLineComment(2);
+        break
+      default:
+        break loop
+      }
+      break
+    default:
+      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+        ++this.pos;
+      } else {
+        break loop
+      }
+    }
+  }
+};
+
+// Called at the end of every token. Sets `end`, `val`, and
+// maintains `context` and `exprAllowed`, and skips the space after
+// the token, so that the next one's `start` will point at the
+// right position.
+
+pp$9.finishToken = function(type, val) {
+  this.end = this.pos;
+  if (this.options.locations) { this.endLoc = this.curPosition(); }
+  var prevType = this.type;
+  this.type = type;
+  this.value = val;
+
+  this.updateContext(prevType);
+};
+
+// ### Token reading
+
+// This is the function that is called to fetch the next token. It
+// is somewhat obscure, because it works in character codes rather
+// than characters, and because operator parsing has been inlined
+// into it.
+//
+// All in the name of speed.
+//
+pp$9.readToken_dot = function() {
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next >= 48 && next <= 57) { return this.readNumber(true) }
+  var next2 = this.input.charCodeAt(this.pos + 2);
+  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+    this.pos += 3;
+    return this.finishToken(types.ellipsis)
+  } else {
+    ++this.pos;
+    return this.finishToken(types.dot)
+  }
+};
+
+pp$9.readToken_slash = function() { // '/'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.slash, 1)
+};
+
+pp$9.readToken_mult_modulo_exp = function(code) { // '%*'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  var tokentype = code === 42 ? types.star : types.modulo;
+
+  // exponentiation operator ** and **=
+  if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
+    ++size;
+    tokentype = types.starstar;
+    next = this.input.charCodeAt(this.pos + 2);
+  }
+
+  if (next === 61) { return this.finishOp(types.assign, size + 1) }
+  return this.finishOp(tokentype, size)
+};
+
+pp$9.readToken_pipe_amp = function(code) { // '|&'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
+};
+
+pp$9.readToken_caret = function() { // '^'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.bitwiseXOR, 1)
+};
+
+pp$9.readToken_plus_min = function(code) { // '+-'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) {
+    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
+        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
+      // A `-->` line comment
+      this.skipLineComment(3);
+      this.skipSpace();
+      return this.nextToken()
+    }
+    return this.finishOp(types.incDec, 2)
+  }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.plusMin, 1)
+};
+
+pp$9.readToken_lt_gt = function(code) { // '<>'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  if (next === code) {
+    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
+    return this.finishOp(types.bitShift, size)
+  }
+  if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
+      this.input.charCodeAt(this.pos + 3) === 45) {
+    // `<!--`, an XML-style comment that should be interpreted as a line comment
+    this.skipLineComment(4);
+    this.skipSpace();
+    return this.nextToken()
+  }
+  if (next === 61) { size = 2; }
+  return this.finishOp(types.relational, size)
+};
+
+pp$9.readToken_eq_excl = function(code) { // '=!'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
+  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+    this.pos += 2;
+    return this.finishToken(types.arrow)
+  }
+  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
+};
+
+pp$9.getTokenFromCode = function(code) {
+  switch (code) {
+  // The interpretation of a dot depends on whether it is followed
+  // by a digit or another two dots.
+  case 46: // '.'
+    return this.readToken_dot()
+
+  // Punctuation tokens.
+  case 40: ++this.pos; return this.finishToken(types.parenL)
+  case 41: ++this.pos; return this.finishToken(types.parenR)
+  case 59: ++this.pos; return this.finishToken(types.semi)
+  case 44: ++this.pos; return this.finishToken(types.comma)
+  case 91: ++this.pos; return this.finishToken(types.bracketL)
+  case 93: ++this.pos; return this.finishToken(types.bracketR)
+  case 123: ++this.pos; return this.finishToken(types.braceL)
+  case 125: ++this.pos; return this.finishToken(types.braceR)
+  case 58: ++this.pos; return this.finishToken(types.colon)
+  case 63: ++this.pos; return this.finishToken(types.question)
+
+  case 96: // '`'
+    if (this.options.ecmaVersion < 6) { break }
+    ++this.pos;
+    return this.finishToken(types.backQuote)
+
+  case 48: // '0'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number
+    if (this.options.ecmaVersion >= 6) {
+      if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number
+      if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number
+    }
+
+  // Anything else beginning with a digit is an integer, octal
+  // number, or float.
+  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
+    return this.readNumber(false)
+
+  // Quotes produce strings.
+  case 34: case 39: // '"', "'"
+    return this.readString(code)
+
+  // Operators are parsed inline in tiny state machines. '=' (61) is
+  // often referred to. `finishOp` simply skips the amount of
+  // characters it is given as second argument, and returns a token
+  // of the type given by its first argument.
+
+  case 47: // '/'
+    return this.readToken_slash()
+
+  case 37: case 42: // '%*'
+    return this.readToken_mult_modulo_exp(code)
+
+  case 124: case 38: // '|&'
+    return this.readToken_pipe_amp(code)
+
+  case 94: // '^'
+    return this.readToken_caret()
+
+  case 43: case 45: // '+-'
+    return this.readToken_plus_min(code)
+
+  case 60: case 62: // '<>'
+    return this.readToken_lt_gt(code)
+
+  case 61: case 33: // '=!'
+    return this.readToken_eq_excl(code)
+
+  case 126: // '~'
+    return this.finishOp(types.prefix, 1)
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+};
+
+pp$9.finishOp = function(type, size) {
+  var str = this.input.slice(this.pos, this.pos + size);
+  this.pos += size;
+  return this.finishToken(type, str)
+};
+
+pp$9.readRegexp = function() {
+  var escaped, inClass, start = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) { this.raise(start, "Unterminated regular expression"); }
+    var ch = this.input.charAt(this.pos);
+    if (lineBreak.test(ch)) { this.raise(start, "Unterminated regular expression"); }
+    if (!escaped) {
+      if (ch === "[") { inClass = true; }
+      else if (ch === "]" && inClass) { inClass = false; }
+      else if (ch === "/" && !inClass) { break }
+      escaped = ch === "\\";
+    } else { escaped = false; }
+    ++this.pos;
+  }
+  var pattern = this.input.slice(start, this.pos);
+  ++this.pos;
+  var flagsStart = this.pos;
+  var flags = this.readWord1();
+  if (this.containsEsc) { this.unexpected(flagsStart); }
+
+  // Validate pattern
+  var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
+  state.reset(start, pattern, flags);
+  this.validateRegExpFlags(state);
+  this.validateRegExpPattern(state);
+
+  // Create Literal#value property value.
+  var value = null;
+  try {
+    value = new RegExp(pattern, flags);
+  } catch (e) {
+    // ESTree requires null if it failed to instantiate RegExp object.
+    // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral
+  }
+
+  return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})
+};
+
+// Read an integer in the given radix. Return null if zero digits
+// were read, the integer value otherwise. When `len` is given, this
+// will return `null` unless the integer has exactly `len` digits.
+
+pp$9.readInt = function(radix, len) {
+  var start = this.pos, total = 0;
+  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    var code = this.input.charCodeAt(this.pos), val = (void 0);
+    if (code >= 97) { val = code - 97 + 10; } // a
+    else if (code >= 65) { val = code - 65 + 10; } // A
+    else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9
+    else { val = Infinity; }
+    if (val >= radix) { break }
+    ++this.pos;
+    total = total * radix + val;
+  }
+  if (this.pos === start || len != null && this.pos - start !== len) { return null }
+
+  return total
+};
+
+pp$9.readRadixNumber = function(radix) {
+  var start = this.pos;
+  this.pos += 2; // 0x
+  var val = this.readInt(radix);
+  if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
+  if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
+    val = typeof BigInt !== "undefined" ? BigInt(this.input.slice(start, this.pos)) : null;
+    ++this.pos;
+  } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+  return this.finishToken(types.num, val)
+};
+
+// Read an integer, octal integer, or floating-point number.
+
+pp$9.readNumber = function(startsWithDot) {
+  var start = this.pos;
+  if (!startsWithDot && this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+  var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
+  if (octal && this.strict) { this.raise(start, "Invalid number"); }
+  if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
+  var next = this.input.charCodeAt(this.pos);
+  if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
+    var str$1 = this.input.slice(start, this.pos);
+    var val$1 = typeof BigInt !== "undefined" ? BigInt(str$1) : null;
+    ++this.pos;
+    if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+    return this.finishToken(types.num, val$1)
+  }
+  if (next === 46 && !octal) { // '.'
+    ++this.pos;
+    this.readInt(10);
+    next = this.input.charCodeAt(this.pos);
+  }
+  if ((next === 69 || next === 101) && !octal) { // 'eE'
+    next = this.input.charCodeAt(++this.pos);
+    if (next === 43 || next === 45) { ++this.pos; } // '+-'
+    if (this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+  }
+  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+
+  var str = this.input.slice(start, this.pos);
+  var val = octal ? parseInt(str, 8) : parseFloat(str);
+  return this.finishToken(types.num, val)
+};
+
+// Read a string value, interpreting backslash-escapes.
+
+pp$9.readCodePoint = function() {
+  var ch = this.input.charCodeAt(this.pos), code;
+
+  if (ch === 123) { // '{'
+    if (this.options.ecmaVersion < 6) { this.unexpected(); }
+    var codePos = ++this.pos;
+    code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
+    ++this.pos;
+    if (code > 0x10FFFF) { this.invalidStringToken(codePos, "Code point out of bounds"); }
+  } else {
+    code = this.readHexChar(4);
+  }
+  return code
+};
+
+function codePointToString$1(code) {
+  // UTF-16 Decoding
+  if (code <= 0xFFFF) { return String.fromCharCode(code) }
+  code -= 0x10000;
+  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
+}
+
+pp$9.readString = function(quote) {
+  var out = "", chunkStart = ++this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated string constant"); }
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === quote) { break }
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar(false);
+      chunkStart = this.pos;
+    } else {
+      if (isNewLine(ch, this.options.ecmaVersion >= 10)) { this.raise(this.start, "Unterminated string constant"); }
+      ++this.pos;
+    }
+  }
+  out += this.input.slice(chunkStart, this.pos++);
+  return this.finishToken(types.string, out)
+};
+
+// Reads template string tokens.
+
+var INVALID_TEMPLATE_ESCAPE_ERROR = {};
+
+pp$9.tryReadTemplateToken = function() {
+  this.inTemplateElement = true;
+  try {
+    this.readTmplToken();
+  } catch (err) {
+    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
+      this.readInvalidTemplateToken();
+    } else {
+      throw err
+    }
+  }
+
+  this.inTemplateElement = false;
+};
+
+pp$9.invalidStringToken = function(position, message) {
+  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
+    throw INVALID_TEMPLATE_ESCAPE_ERROR
+  } else {
+    this.raise(position, message);
+  }
+};
+
+pp$9.readTmplToken = function() {
+  var out = "", chunkStart = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated template"); }
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
+      if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {
+        if (ch === 36) {
+          this.pos += 2;
+          return this.finishToken(types.dollarBraceL)
+        } else {
+          ++this.pos;
+          return this.finishToken(types.backQuote)
+        }
+      }
+      out += this.input.slice(chunkStart, this.pos);
+      return this.finishToken(types.template, out)
+    }
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar(true);
+      chunkStart = this.pos;
+    } else if (isNewLine(ch)) {
+      out += this.input.slice(chunkStart, this.pos);
+      ++this.pos;
+      switch (ch) {
+      case 13:
+        if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }
+      case 10:
+        out += "\n";
+        break
+      default:
+        out += String.fromCharCode(ch);
+        break
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      chunkStart = this.pos;
+    } else {
+      ++this.pos;
+    }
+  }
+};
+
+// Reads a template token to search for the end, without validating any escape sequences
+pp$9.readInvalidTemplateToken = function() {
+  for (; this.pos < this.input.length; this.pos++) {
+    switch (this.input[this.pos]) {
+    case "\\":
+      ++this.pos;
+      break
+
+    case "$":
+      if (this.input[this.pos + 1] !== "{") {
+        break
+      }
+    // falls through
+
+    case "`":
+      return this.finishToken(types.invalidTemplate, this.input.slice(this.start, this.pos))
+
+    // no default
+    }
+  }
+  this.raise(this.start, "Unterminated template");
+};
+
+// Used to read escaped characters
+
+pp$9.readEscapedChar = function(inTemplate) {
+  var ch = this.input.charCodeAt(++this.pos);
+  ++this.pos;
+  switch (ch) {
+  case 110: return "\n" // 'n' -> '\n'
+  case 114: return "\r" // 'r' -> '\r'
+  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'
+  case 117: return codePointToString$1(this.readCodePoint()) // 'u'
+  case 116: return "\t" // 't' -> '\t'
+  case 98: return "\b" // 'b' -> '\b'
+  case 118: return "\u000b" // 'v' -> '\u000b'
+  case 102: return "\f" // 'f' -> '\f'
+  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\r\n'
+  case 10: // ' \n'
+    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+    return ""
+  default:
+    if (ch >= 48 && ch <= 55) {
+      var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
+      var octal = parseInt(octalStr, 8);
+      if (octal > 255) {
+        octalStr = octalStr.slice(0, -1);
+        octal = parseInt(octalStr, 8);
+      }
+      this.pos += octalStr.length - 1;
+      ch = this.input.charCodeAt(this.pos);
+      if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
+        this.invalidStringToken(
+          this.pos - 1 - octalStr.length,
+          inTemplate
+            ? "Octal literal in template string"
+            : "Octal literal in strict mode"
+        );
+      }
+      return String.fromCharCode(octal)
+    }
+    if (isNewLine(ch)) {
+      // Unicode new line characters after \ get removed from output in both
+      // template literals and strings
+      return ""
+    }
+    return String.fromCharCode(ch)
+  }
+};
+
+// Used to read character escape sequences ('\x', '\u', '\U').
+
+pp$9.readHexChar = function(len) {
+  var codePos = this.pos;
+  var n = this.readInt(16, len);
+  if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
+  return n
+};
+
+// Read an identifier, and return it as a string. Sets `this.containsEsc`
+// to whether the word contained a '\u' escape.
+//
+// Incrementally adds only escaped chars, adding other chunks as-is
+// as a micro-optimization.
+
+pp$9.readWord1 = function() {
+  this.containsEsc = false;
+  var word = "", first = true, chunkStart = this.pos;
+  var astral = this.options.ecmaVersion >= 6;
+  while (this.pos < this.input.length) {
+    var ch = this.fullCharCodeAtPos();
+    if (isIdentifierChar(ch, astral)) {
+      this.pos += ch <= 0xffff ? 1 : 2;
+    } else if (ch === 92) { // "\"
+      this.containsEsc = true;
+      word += this.input.slice(chunkStart, this.pos);
+      var escStart = this.pos;
+      if (this.input.charCodeAt(++this.pos) !== 117) // "u"
+        { this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX"); }
+      ++this.pos;
+      var esc = this.readCodePoint();
+      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+        { this.invalidStringToken(escStart, "Invalid Unicode escape"); }
+      word += codePointToString$1(esc);
+      chunkStart = this.pos;
+    } else {
+      break
+    }
+    first = false;
+  }
+  return word + this.input.slice(chunkStart, this.pos)
+};
+
+// Read an identifier or keyword token. Will check for reserved
+// words when necessary.
+
+pp$9.readWord = function() {
+  var word = this.readWord1();
+  var type = types.name;
+  if (this.keywords.test(word)) {
+    if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword " + word); }
+    type = keywords$1[word];
+  }
+  return this.finishToken(type, word)
+};
+
+// Acorn is a tiny, fast JavaScript parser written in JavaScript.
+
+var version = "6.4.0";
+
+Parser.acorn = {
+  Parser: Parser,
+  version: version,
+  defaultOptions: defaultOptions,
+  Position: Position,
+  SourceLocation: SourceLocation,
+  getLineInfo: getLineInfo,
+  Node: Node,
+  TokenType: TokenType,
+  tokTypes: types,
+  keywordTypes: keywords$1,
+  TokContext: TokContext,
+  tokContexts: types$1,
+  isIdentifierChar: isIdentifierChar,
+  isIdentifierStart: isIdentifierStart,
+  Token: Token,
+  isNewLine: isNewLine,
+  lineBreak: lineBreak,
+  lineBreakG: lineBreakG,
+  nonASCIIwhitespace: nonASCIIwhitespace
+};
+
+// The main exported interface (under `self.acorn` when in the
+// browser) is a `parse` function that takes a code string and
+// returns an abstract syntax tree as specified by [Mozilla parser
+// API][api].
+//
+// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+
+function parse(input, options) {
+  return Parser.parse(input, options)
+}
+
+// This function tries to parse a single expression at a given
+// offset in a string. Useful for parsing mixed-language formats
+// that embed JavaScript expressions.
+
+function parseExpressionAt(input, pos, options) {
+  return Parser.parseExpressionAt(input, pos, options)
+}
+
+// Acorn is organized as a tokenizer and a recursive-descent parser.
+// The `tokenizer` export provides an interface to the tokenizer.
+
+function tokenizer(input, options) {
+  return Parser.tokenizer(input, options)
+}
+
+export { Node, Parser, Position, SourceLocation, TokContext, Token, TokenType, defaultOptions, getLineInfo, isIdentifierChar, isIdentifierStart, isNewLine, keywords$1 as keywordTypes, lineBreak, lineBreakG, nonASCIIwhitespace, parse, parseExpressionAt, types$1 as tokContexts, types as tokTypes, tokenizer, version };
diff --git a/node_modules/acorn-globals/node_modules/acorn/dist/acorn.mjs.map b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.mjs.map
new file mode 100644
index 0000000..76ec4d5
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/dist/acorn.mjs.map
@@ -0,0 +1 @@
+{"version":3,"file":"acorn.mjs","sources":["../src/identifier.js","../src/tokentype.js","../src/whitespace.js","../src/util.js","../src/locutil.js","../src/options.js","../src/scopeflags.js","../src/state.js","../src/parseutil.js","../src/statement.js","../src/lval.js","../src/expression.js","../src/location.js","../src/scope.js","../src/node.js","../src/tokencontext.js","../src/unicode-property-data.js","../src/regexp.js","../src/tokenize.js","../src/index.js"],"sourcesContent":["// Reserved word lists for various dialects of the language\n\nexport const reservedWords = {\n  3: \"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile\",\n  5: \"class enum extends super const export import\",\n  6: \"enum\",\n  strict: \"implements interface let package private protected public static yield\",\n  strictBind: \"eval arguments\"\n}\n\n// And the keywords\n\nconst ecma5AndLessKeywords = \"break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this\"\n\nexport const keywords = {\n  5: ecma5AndLessKeywords,\n  6: ecma5AndLessKeywords + \" const class extends export import super\"\n}\n\nexport const keywordRelationalOperator = /^in(stanceof)?$/\n\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\n// Generated by `bin/generate-identifier-regex.js`.\n\nlet nonASCIIidentifierStartChars = \"\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u08a0-\\u08b4\\u08b6-\\u08bd\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fef\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7b9\\ua7f7-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab65\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\"\nlet nonASCIIidentifierChars = \"\\u200c\\u200d\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u08d3-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0eb9\\u0ebb\\u0ebc\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf2-\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1df9\\u1dfb-\\u1dff\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\"\n\nconst nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\")\nconst nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\")\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null\n\n// These are a run-length and offset encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by bin/generate-identifier-regex.js\n\n// eslint-disable-next-line comma-spacing\nconst astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,190,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,26,230,43,117,63,32,0,257,0,11,39,8,0,22,0,12,39,3,3,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,68,12,0,67,12,65,1,31,6129,15,754,9486,286,82,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541]\n\n// eslint-disable-next-line comma-spacing\nconst astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,280,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239]\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code, set) {\n  let pos = 0x10000\n  for (let i = 0; i < set.length; i += 2) {\n    pos += set[i]\n    if (pos > code) return false\n    pos += set[i + 1]\n    if (pos >= code) return true\n  }\n}\n\n// Test whether a given character code starts an identifier.\n\nexport function isIdentifierStart(code, astral) {\n  if (code < 65) return code === 36\n  if (code < 91) return true\n  if (code < 97) return code === 95\n  if (code < 123) return true\n  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))\n  if (astral === false) return false\n  return isInAstralSet(code, astralIdentifierStartCodes)\n}\n\n// Test whether a given character is part of an identifier.\n\nexport function isIdentifierChar(code, astral) {\n  if (code < 48) return code === 36\n  if (code < 58) return true\n  if (code < 65) return false\n  if (code < 91) return true\n  if (code < 97) return code === 95\n  if (code < 123) return true\n  if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code))\n  if (astral === false) return false\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)\n}\n","// ## Token types\n\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n\n// The `beforeExpr` property is used to disambiguate between regular\n// expressions and divisions. It is set on all token types that can\n// be followed by an expression (thus, a slash after them would be a\n// regular expression).\n//\n// The `startsExpr` property is used to check if the token ends a\n// `yield` expression. It is set on all token types that either can\n// directly start an expression (like a quotation mark) or can\n// continue an expression (like the body of a string).\n//\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\nexport class TokenType {\n  constructor(label, conf = {}) {\n    this.label = label\n    this.keyword = conf.keyword\n    this.beforeExpr = !!conf.beforeExpr\n    this.startsExpr = !!conf.startsExpr\n    this.isLoop = !!conf.isLoop\n    this.isAssign = !!conf.isAssign\n    this.prefix = !!conf.prefix\n    this.postfix = !!conf.postfix\n    this.binop = conf.binop || null\n    this.updateContext = null\n  }\n}\n\nfunction binop(name, prec) {\n  return new TokenType(name, {beforeExpr: true, binop: prec})\n}\nconst beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true}\n\n// Map keyword names to token types.\n\nexport const keywords = {}\n\n// Succinct definitions of keyword token types\nfunction kw(name, options = {}) {\n  options.keyword = name\n  return keywords[name] = new TokenType(name, options)\n}\n\nexport const types = {\n  num: new TokenType(\"num\", startsExpr),\n  regexp: new TokenType(\"regexp\", startsExpr),\n  string: new TokenType(\"string\", startsExpr),\n  name: new TokenType(\"name\", startsExpr),\n  eof: new TokenType(\"eof\"),\n\n  // Punctuation token types.\n  bracketL: new TokenType(\"[\", {beforeExpr: true, startsExpr: true}),\n  bracketR: new TokenType(\"]\"),\n  braceL: new TokenType(\"{\", {beforeExpr: true, startsExpr: true}),\n  braceR: new TokenType(\"}\"),\n  parenL: new TokenType(\"(\", {beforeExpr: true, startsExpr: true}),\n  parenR: new TokenType(\")\"),\n  comma: new TokenType(\",\", beforeExpr),\n  semi: new TokenType(\";\", beforeExpr),\n  colon: new TokenType(\":\", beforeExpr),\n  dot: new TokenType(\".\"),\n  question: new TokenType(\"?\", beforeExpr),\n  arrow: new TokenType(\"=>\", beforeExpr),\n  template: new TokenType(\"template\"),\n  invalidTemplate: new TokenType(\"invalidTemplate\"),\n  ellipsis: new TokenType(\"...\", beforeExpr),\n  backQuote: new TokenType(\"`\", startsExpr),\n  dollarBraceL: new TokenType(\"${\", {beforeExpr: true, startsExpr: true}),\n\n  // Operators. These carry several kinds of properties to help the\n  // parser use them properly (the presence of these properties is\n  // what categorizes them as operators).\n  //\n  // `binop`, when present, specifies that this operator is a binary\n  // operator, and will refer to its precedence.\n  //\n  // `prefix` and `postfix` mark the operator as a prefix or postfix\n  // unary operator.\n  //\n  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n  // binary operators with a very low precedence, that should result\n  // in AssignmentExpression nodes.\n\n  eq: new TokenType(\"=\", {beforeExpr: true, isAssign: true}),\n  assign: new TokenType(\"_=\", {beforeExpr: true, isAssign: true}),\n  incDec: new TokenType(\"++/--\", {prefix: true, postfix: true, startsExpr: true}),\n  prefix: new TokenType(\"!/~\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  logicalOR: binop(\"||\", 1),\n  logicalAND: binop(\"&&\", 2),\n  bitwiseOR: binop(\"|\", 3),\n  bitwiseXOR: binop(\"^\", 4),\n  bitwiseAND: binop(\"&\", 5),\n  equality: binop(\"==/!=/===/!==\", 6),\n  relational: binop(\"</>/<=/>=\", 7),\n  bitShift: binop(\"<</>>/>>>\", 8),\n  plusMin: new TokenType(\"+/-\", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),\n  modulo: binop(\"%\", 10),\n  star: binop(\"*\", 10),\n  slash: binop(\"/\", 10),\n  starstar: new TokenType(\"**\", {beforeExpr: true}),\n\n  // Keyword token types.\n  _break: kw(\"break\"),\n  _case: kw(\"case\", beforeExpr),\n  _catch: kw(\"catch\"),\n  _continue: kw(\"continue\"),\n  _debugger: kw(\"debugger\"),\n  _default: kw(\"default\", beforeExpr),\n  _do: kw(\"do\", {isLoop: true, beforeExpr: true}),\n  _else: kw(\"else\", beforeExpr),\n  _finally: kw(\"finally\"),\n  _for: kw(\"for\", {isLoop: true}),\n  _function: kw(\"function\", startsExpr),\n  _if: kw(\"if\"),\n  _return: kw(\"return\", beforeExpr),\n  _switch: kw(\"switch\"),\n  _throw: kw(\"throw\", beforeExpr),\n  _try: kw(\"try\"),\n  _var: kw(\"var\"),\n  _const: kw(\"const\"),\n  _while: kw(\"while\", {isLoop: true}),\n  _with: kw(\"with\"),\n  _new: kw(\"new\", {beforeExpr: true, startsExpr: true}),\n  _this: kw(\"this\", startsExpr),\n  _super: kw(\"super\", startsExpr),\n  _class: kw(\"class\", startsExpr),\n  _extends: kw(\"extends\", beforeExpr),\n  _export: kw(\"export\"),\n  _import: kw(\"import\"),\n  _null: kw(\"null\", startsExpr),\n  _true: kw(\"true\", startsExpr),\n  _false: kw(\"false\", startsExpr),\n  _in: kw(\"in\", {beforeExpr: true, binop: 7}),\n  _instanceof: kw(\"instanceof\", {beforeExpr: true, binop: 7}),\n  _typeof: kw(\"typeof\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _void: kw(\"void\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _delete: kw(\"delete\", {beforeExpr: true, prefix: true, startsExpr: true})\n}\n","// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\n\nexport const lineBreak = /\\r\\n?|\\n|\\u2028|\\u2029/\nexport const lineBreakG = new RegExp(lineBreak.source, \"g\")\n\nexport function isNewLine(code, ecma2019String) {\n  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))\n}\n\nexport const nonASCIIwhitespace = /[\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff]/\n\nexport const skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g\n","const {hasOwnProperty, toString} = Object.prototype\n\n// Checks if an object has a property.\n\nexport function has(obj, propName) {\n  return hasOwnProperty.call(obj, propName)\n}\n\nexport const isArray = Array.isArray || ((obj) => (\n  toString.call(obj) === \"[object Array]\"\n))\n\nexport function wordsRegexp(words) {\n  return new RegExp(\"^(?:\" + words.replace(/ /g, \"|\") + \")$\")\n}\n","import {lineBreakG} from \"./whitespace\"\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nexport class Position {\n  constructor(line, col) {\n    this.line = line\n    this.column = col\n  }\n\n  offset(n) {\n    return new Position(this.line, this.column + n)\n  }\n}\n\nexport class SourceLocation {\n  constructor(p, start, end) {\n    this.start = start\n    this.end = end\n    if (p.sourceFile !== null) this.source = p.sourceFile\n  }\n}\n\n// The `getLineInfo` function is mostly useful when the\n// `locations` option is off (for performance reasons) and you\n// want to find the line/column position for a given character\n// offset. `input` should be the code string that the offset refers\n// into.\n\nexport function getLineInfo(input, offset) {\n  for (let line = 1, cur = 0;;) {\n    lineBreakG.lastIndex = cur\n    let match = lineBreakG.exec(input)\n    if (match && match.index < offset) {\n      ++line\n      cur = match.index + match[0].length\n    } else {\n      return new Position(line, offset - cur)\n    }\n  }\n}\n","import {has, isArray} from \"./util\"\nimport {SourceLocation} from \"./locutil\"\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nexport const defaultOptions = {\n  // `ecmaVersion` indicates the ECMAScript version to parse. Must be\n  // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10\n  // (2019). This influences support for strict mode, the set of\n  // reserved words, and support for new syntax features. The default\n  // is 9.\n  ecmaVersion: 9,\n  // `sourceType` indicates the mode the code should be parsed in.\n  // Can be either `\"script\"` or `\"module\"`. This influences global\n  // strict mode and parsing of `import` and `export` declarations.\n  sourceType: \"script\",\n  // `onInsertedSemicolon` can be a callback that will be called\n  // when a semicolon is automatically inserted. It will be passed\n  // the position of the comma as an offset, and if `locations` is\n  // enabled, it is given the location as a `{line, column}` object\n  // as second argument.\n  onInsertedSemicolon: null,\n  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for\n  // trailing commas.\n  onTrailingComma: null,\n  // By default, reserved words are only enforced if ecmaVersion >= 5.\n  // Set `allowReserved` to a boolean value to explicitly turn this on\n  // an off. When this option has the value \"never\", reserved words\n  // and keywords can also not be used as property names.\n  allowReserved: null,\n  // When enabled, a return at the top level is not considered an\n  // error.\n  allowReturnOutsideFunction: false,\n  // When enabled, import/export statements are not constrained to\n  // appearing at the top of the program.\n  allowImportExportEverywhere: false,\n  // When enabled, await identifiers are allowed to appear at the top-level scope,\n  // but they are still not allowed in non-async functions.\n  allowAwaitOutsideFunction: false,\n  // When enabled, hashbang directive in the beginning of file\n  // is allowed and treated as a line comment.\n  allowHashBang: false,\n  // When `locations` is on, `loc` properties holding objects with\n  // `start` and `end` properties in `{line, column}` form (with\n  // line being 1-based and column 0-based) will be attached to the\n  // nodes.\n  locations: false,\n  // A function can be passed as `onToken` option, which will\n  // cause Acorn to call that function with object in the same\n  // format as tokens returned from `tokenizer().getToken()`. Note\n  // that you are not allowed to call the parser from the\n  // callback—that will corrupt its internal state.\n  onToken: null,\n  // A function can be passed as `onComment` option, which will\n  // cause Acorn to call that function with `(block, text, start,\n  // end)` parameters whenever a comment is skipped. `block` is a\n  // boolean indicating whether this is a block (`/* */`) comment,\n  // `text` is the content of the comment, and `start` and `end` are\n  // character offsets that denote the start and end of the comment.\n  // When the `locations` option is on, two more parameters are\n  // passed, the full `{line, column}` locations of the start and\n  // end of the comments. Note that you are not allowed to call the\n  // parser from the callback—that will corrupt its internal state.\n  onComment: null,\n  // Nodes have their start and end characters offsets recorded in\n  // `start` and `end` properties (directly on the node, rather than\n  // the `loc` object, which holds line/column data. To also add a\n  // [semi-standardized][range] `range` property holding a `[start,\n  // end]` array with the same numbers, set the `ranges` option to\n  // `true`.\n  //\n  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n  ranges: false,\n  // It is possible to parse multiple files into a single AST by\n  // passing the tree produced by parsing the first file as\n  // `program` option in subsequent parses. This will add the\n  // toplevel forms of the parsed file to the `Program` (top) node\n  // of an existing parse tree.\n  program: null,\n  // When `locations` is on, you can pass this to record the source\n  // file in every node's `loc` object.\n  sourceFile: null,\n  // This value, if given, is stored in every node, whether\n  // `locations` is on or off.\n  directSourceFile: null,\n  // When enabled, parenthesized expressions are represented by\n  // (non-standard) ParenthesizedExpression nodes\n  preserveParens: false\n}\n\n// Interpret and default an options object\n\nexport function getOptions(opts) {\n  let options = {}\n\n  for (let opt in defaultOptions)\n    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]\n\n  if (options.ecmaVersion >= 2015)\n    options.ecmaVersion -= 2009\n\n  if (options.allowReserved == null)\n    options.allowReserved = options.ecmaVersion < 5\n\n  if (isArray(options.onToken)) {\n    let tokens = options.onToken\n    options.onToken = (token) => tokens.push(token)\n  }\n  if (isArray(options.onComment))\n    options.onComment = pushComment(options, options.onComment)\n\n  return options\n}\n\nfunction pushComment(options, array) {\n  return function(block, text, start, end, startLoc, endLoc) {\n    let comment = {\n      type: block ? \"Block\" : \"Line\",\n      value: text,\n      start: start,\n      end: end\n    }\n    if (options.locations)\n      comment.loc = new SourceLocation(this, startLoc, endLoc)\n    if (options.ranges)\n      comment.range = [start, end]\n    array.push(comment)\n  }\n}\n","// Each scope gets a bitset that may contain these flags\nexport const\n    SCOPE_TOP = 1,\n    SCOPE_FUNCTION = 2,\n    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,\n    SCOPE_ASYNC = 4,\n    SCOPE_GENERATOR = 8,\n    SCOPE_ARROW = 16,\n    SCOPE_SIMPLE_CATCH = 32,\n    SCOPE_SUPER = 64,\n    SCOPE_DIRECT_SUPER = 128\n\nexport function functionFlags(async, generator) {\n  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)\n}\n\n// Used in checkLVal and declareName to determine the type of a binding\nexport const\n    BIND_NONE = 0, // Not a binding\n    BIND_VAR = 1, // Var-style binding\n    BIND_LEXICAL = 2, // Let- or const-style binding\n    BIND_FUNCTION = 3, // Function declaration\n    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding\n    BIND_OUTSIDE = 5 // Special case for function names as bound inside the function\n","import {reservedWords, keywords} from \"./identifier\"\nimport {types as tt} from \"./tokentype\"\nimport {lineBreak} from \"./whitespace\"\nimport {getOptions} from \"./options\"\nimport {wordsRegexp} from \"./util\"\nimport {SCOPE_TOP, SCOPE_FUNCTION, SCOPE_ASYNC, SCOPE_GENERATOR, SCOPE_SUPER, SCOPE_DIRECT_SUPER} from \"./scopeflags\"\n\nexport class Parser {\n  constructor(options, input, startPos) {\n    this.options = options = getOptions(options)\n    this.sourceFile = options.sourceFile\n    this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5])\n    let reserved = \"\"\n    if (!options.allowReserved) {\n      for (let v = options.ecmaVersion;; v--)\n        if (reserved = reservedWords[v]) break\n      if (options.sourceType === \"module\") reserved += \" await\"\n    }\n    this.reservedWords = wordsRegexp(reserved)\n    let reservedStrict = (reserved ? reserved + \" \" : \"\") + reservedWords.strict\n    this.reservedWordsStrict = wordsRegexp(reservedStrict)\n    this.reservedWordsStrictBind = wordsRegexp(reservedStrict + \" \" + reservedWords.strictBind)\n    this.input = String(input)\n\n    // Used to signal to callers of `readWord1` whether the word\n    // contained any escape sequences. This is needed because words with\n    // escape sequences must not be interpreted as keywords.\n    this.containsEsc = false\n\n    // Set up token state\n\n    // The current position of the tokenizer in the input.\n    if (startPos) {\n      this.pos = startPos\n      this.lineStart = this.input.lastIndexOf(\"\\n\", startPos - 1) + 1\n      this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length\n    } else {\n      this.pos = this.lineStart = 0\n      this.curLine = 1\n    }\n\n    // Properties of the current token:\n    // Its type\n    this.type = tt.eof\n    // For tokens that include more information than their type, the value\n    this.value = null\n    // Its start and end offset\n    this.start = this.end = this.pos\n    // And, if locations are used, the {line, column} object\n    // corresponding to those offsets\n    this.startLoc = this.endLoc = this.curPosition()\n\n    // Position information for the previous token\n    this.lastTokEndLoc = this.lastTokStartLoc = null\n    this.lastTokStart = this.lastTokEnd = this.pos\n\n    // The context stack is used to superficially track syntactic\n    // context to predict whether a regular expression is allowed in a\n    // given position.\n    this.context = this.initialContext()\n    this.exprAllowed = true\n\n    // Figure out if it's a module code.\n    this.inModule = options.sourceType === \"module\"\n    this.strict = this.inModule || this.strictDirective(this.pos)\n\n    // Used to signify the start of a potential arrow function\n    this.potentialArrowAt = -1\n\n    // Positions to delayed-check that yield/await does not exist in default parameters.\n    this.yieldPos = this.awaitPos = this.awaitIdentPos = 0\n    // Labels in scope.\n    this.labels = []\n    // Thus-far undefined exports.\n    this.undefinedExports = {}\n\n    // If enabled, skip leading hashbang line.\n    if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === \"#!\")\n      this.skipLineComment(2)\n\n    // Scope tracking for duplicate variable names (see scope.js)\n    this.scopeStack = []\n    this.enterScope(SCOPE_TOP)\n\n    // For RegExp validation\n    this.regexpState = null\n  }\n\n  parse() {\n    let node = this.options.program || this.startNode()\n    this.nextToken()\n    return this.parseTopLevel(node)\n  }\n\n  get inFunction() { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 }\n  get inGenerator() { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 }\n  get inAsync() { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 }\n  get allowSuper() { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 }\n  get allowDirectSuper() { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 }\n  get treatFunctionsAsVar() { return this.treatFunctionsAsVarInScope(this.currentScope()) }\n\n  // Switch to a getter for 7.0.0.\n  inNonArrowFunction() { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 }\n\n  static extend(...plugins) {\n    let cls = this\n    for (let i = 0; i < plugins.length; i++) cls = plugins[i](cls)\n    return cls\n  }\n\n  static parse(input, options) {\n    return new this(options, input).parse()\n  }\n\n  static parseExpressionAt(input, pos, options) {\n    let parser = new this(options, input, pos)\n    parser.nextToken()\n    return parser.parseExpression()\n  }\n\n  static tokenizer(input, options) {\n    return new this(options, input)\n  }\n}\n","import {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {lineBreak, skipWhiteSpace} from \"./whitespace\"\n\nconst pp = Parser.prototype\n\n// ## Parser utilities\n\nconst literal = /^(?:'((?:\\\\.|[^'])*?)'|\"((?:\\\\.|[^\"])*?)\")/\npp.strictDirective = function(start) {\n  for (;;) {\n    // Try to find string literal.\n    skipWhiteSpace.lastIndex = start\n    start += skipWhiteSpace.exec(this.input)[0].length\n    let match = literal.exec(this.input.slice(start))\n    if (!match) return false\n    if ((match[1] || match[2]) === \"use strict\") return true\n    start += match[0].length\n\n    // Skip semicolon, if any.\n    skipWhiteSpace.lastIndex = start\n    start += skipWhiteSpace.exec(this.input)[0].length\n    if (this.input[start] === \";\")\n      start++\n  }\n}\n\n// Predicate that tests whether the next token is of the given\n// type, and if yes, consumes it as a side effect.\n\npp.eat = function(type) {\n  if (this.type === type) {\n    this.next()\n    return true\n  } else {\n    return false\n  }\n}\n\n// Tests whether parsed token is a contextual keyword.\n\npp.isContextual = function(name) {\n  return this.type === tt.name && this.value === name && !this.containsEsc\n}\n\n// Consumes contextual keyword if possible.\n\npp.eatContextual = function(name) {\n  if (!this.isContextual(name)) return false\n  this.next()\n  return true\n}\n\n// Asserts that following token is given contextual keyword.\n\npp.expectContextual = function(name) {\n  if (!this.eatContextual(name)) this.unexpected()\n}\n\n// Test whether a semicolon can be inserted at the current position.\n\npp.canInsertSemicolon = function() {\n  return this.type === tt.eof ||\n    this.type === tt.braceR ||\n    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n}\n\npp.insertSemicolon = function() {\n  if (this.canInsertSemicolon()) {\n    if (this.options.onInsertedSemicolon)\n      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)\n    return true\n  }\n}\n\n// Consume a semicolon, or, failing that, see if we are allowed to\n// pretend that there is a semicolon at this position.\n\npp.semicolon = function() {\n  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected()\n}\n\npp.afterTrailingComma = function(tokType, notNext) {\n  if (this.type === tokType) {\n    if (this.options.onTrailingComma)\n      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc)\n    if (!notNext)\n      this.next()\n    return true\n  }\n}\n\n// Expect a token of a given type. If found, consume it, otherwise,\n// raise an unexpected token error.\n\npp.expect = function(type) {\n  this.eat(type) || this.unexpected()\n}\n\n// Raise an unexpected token error.\n\npp.unexpected = function(pos) {\n  this.raise(pos != null ? pos : this.start, \"Unexpected token\")\n}\n\nexport function DestructuringErrors() {\n  this.shorthandAssign =\n  this.trailingComma =\n  this.parenthesizedAssign =\n  this.parenthesizedBind =\n  this.doubleProto =\n    -1\n}\n\npp.checkPatternErrors = function(refDestructuringErrors, isAssign) {\n  if (!refDestructuringErrors) return\n  if (refDestructuringErrors.trailingComma > -1)\n    this.raiseRecoverable(refDestructuringErrors.trailingComma, \"Comma is not permitted after the rest element\")\n  let parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind\n  if (parens > -1) this.raiseRecoverable(parens, \"Parenthesized pattern\")\n}\n\npp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {\n  if (!refDestructuringErrors) return false\n  let {shorthandAssign, doubleProto} = refDestructuringErrors\n  if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0\n  if (shorthandAssign >= 0)\n    this.raise(shorthandAssign, \"Shorthand property assignments are valid only in destructuring patterns\")\n  if (doubleProto >= 0)\n    this.raiseRecoverable(doubleProto, \"Redefinition of __proto__ property\")\n}\n\npp.checkYieldAwaitInDefaultParams = function() {\n  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))\n    this.raise(this.yieldPos, \"Yield expression cannot be a default value\")\n  if (this.awaitPos)\n    this.raise(this.awaitPos, \"Await expression cannot be a default value\")\n}\n\npp.isSimpleAssignTarget = function(expr) {\n  if (expr.type === \"ParenthesizedExpression\")\n    return this.isSimpleAssignTarget(expr.expression)\n  return expr.type === \"Identifier\" || expr.type === \"MemberExpression\"\n}\n","import {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {lineBreak, skipWhiteSpace} from \"./whitespace\"\nimport {isIdentifierStart, isIdentifierChar, keywordRelationalOperator} from \"./identifier\"\nimport {has} from \"./util\"\nimport {DestructuringErrors} from \"./parseutil\"\nimport {functionFlags, SCOPE_SIMPLE_CATCH, BIND_SIMPLE_CATCH, BIND_LEXICAL, BIND_VAR, BIND_FUNCTION} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\n// ### Statement parsing\n\n// Parse a program. Initializes the parser, reads any number of\n// statements, and wraps them in a Program node.  Optionally takes a\n// `program` argument.  If present, the statements will be appended\n// to its body instead of creating a new node.\n\npp.parseTopLevel = function(node) {\n  let exports = {}\n  if (!node.body) node.body = []\n  while (this.type !== tt.eof) {\n    let stmt = this.parseStatement(null, true, exports)\n    node.body.push(stmt)\n  }\n  if (this.inModule)\n    for (let name of Object.keys(this.undefinedExports))\n      this.raiseRecoverable(this.undefinedExports[name].start, `Export '${name}' is not defined`)\n  this.adaptDirectivePrologue(node.body)\n  this.next()\n  if (this.options.ecmaVersion >= 6) {\n    node.sourceType = this.options.sourceType\n  }\n  return this.finishNode(node, \"Program\")\n}\n\nconst loopLabel = {kind: \"loop\"}, switchLabel = {kind: \"switch\"}\n\npp.isLet = function(context) {\n  if (this.options.ecmaVersion < 6 || !this.isContextual(\"let\")) return false\n  skipWhiteSpace.lastIndex = this.pos\n  let skip = skipWhiteSpace.exec(this.input)\n  let next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next)\n  // For ambiguous cases, determine if a LexicalDeclaration (or only a\n  // Statement) is allowed here. If context is not empty then only a Statement\n  // is allowed. However, `let [` is an explicit negative lookahead for\n  // ExpressionStatement, so special-case it first.\n  if (nextCh === 91) return true // '['\n  if (context) return false\n\n  if (nextCh === 123) return true // '{'\n  if (isIdentifierStart(nextCh, true)) {\n    let pos = next + 1\n    while (isIdentifierChar(this.input.charCodeAt(pos), true)) ++pos\n    let ident = this.input.slice(next, pos)\n    if (!keywordRelationalOperator.test(ident)) return true\n  }\n  return false\n}\n\n// check 'async [no LineTerminator here] function'\n// - 'async /*foo*/ function' is OK.\n// - 'async /*\\n*/ function' is invalid.\npp.isAsyncFunction = function() {\n  if (this.options.ecmaVersion < 8 || !this.isContextual(\"async\"))\n    return false\n\n  skipWhiteSpace.lastIndex = this.pos\n  let skip = skipWhiteSpace.exec(this.input)\n  let next = this.pos + skip[0].length\n  return !lineBreak.test(this.input.slice(this.pos, next)) &&\n    this.input.slice(next, next + 8) === \"function\" &&\n    (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))\n}\n\n// Parse a single statement.\n//\n// If expecting a statement and finding a slash operator, parse a\n// regular expression literal. This is to handle cases like\n// `if (foo) /blah/.exec(foo)`, where looking at the previous token\n// does not help.\n\npp.parseStatement = function(context, topLevel, exports) {\n  let starttype = this.type, node = this.startNode(), kind\n\n  if (this.isLet(context)) {\n    starttype = tt._var\n    kind = \"let\"\n  }\n\n  // Most types of statements are recognized by the keyword they\n  // start with. Many are trivial to parse, some require a bit of\n  // complexity.\n\n  switch (starttype) {\n  case tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword)\n  case tt._debugger: return this.parseDebuggerStatement(node)\n  case tt._do: return this.parseDoStatement(node)\n  case tt._for: return this.parseForStatement(node)\n  case tt._function:\n    // Function as sole body of either an if statement or a labeled statement\n    // works, but not when it is part of a labeled statement that is the sole\n    // body of an if statement.\n    if ((context && (this.strict || context !== \"if\" && context !== \"label\")) && this.options.ecmaVersion >= 6) this.unexpected()\n    return this.parseFunctionStatement(node, false, !context)\n  case tt._class:\n    if (context) this.unexpected()\n    return this.parseClass(node, true)\n  case tt._if: return this.parseIfStatement(node)\n  case tt._return: return this.parseReturnStatement(node)\n  case tt._switch: return this.parseSwitchStatement(node)\n  case tt._throw: return this.parseThrowStatement(node)\n  case tt._try: return this.parseTryStatement(node)\n  case tt._const: case tt._var:\n    kind = kind || this.value\n    if (context && kind !== \"var\") this.unexpected()\n    return this.parseVarStatement(node, kind)\n  case tt._while: return this.parseWhileStatement(node)\n  case tt._with: return this.parseWithStatement(node)\n  case tt.braceL: return this.parseBlock(true, node)\n  case tt.semi: return this.parseEmptyStatement(node)\n  case tt._export:\n  case tt._import:\n    if (!this.options.allowImportExportEverywhere) {\n      if (!topLevel)\n        this.raise(this.start, \"'import' and 'export' may only appear at the top level\")\n      if (!this.inModule)\n        this.raise(this.start, \"'import' and 'export' may appear only with 'sourceType: module'\")\n    }\n    return starttype === tt._import ? this.parseImport(node) : this.parseExport(node, exports)\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n  default:\n    if (this.isAsyncFunction()) {\n      if (context) this.unexpected()\n      this.next()\n      return this.parseFunctionStatement(node, true, !context)\n    }\n\n    let maybeName = this.value, expr = this.parseExpression()\n    if (starttype === tt.name && expr.type === \"Identifier\" && this.eat(tt.colon))\n      return this.parseLabeledStatement(node, maybeName, expr, context)\n    else return this.parseExpressionStatement(node, expr)\n  }\n}\n\npp.parseBreakContinueStatement = function(node, keyword) {\n  let isBreak = keyword === \"break\"\n  this.next()\n  if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null\n  else if (this.type !== tt.name) this.unexpected()\n  else {\n    node.label = this.parseIdent()\n    this.semicolon()\n  }\n\n  // Verify that there is an actual destination to break or\n  // continue to.\n  let i = 0\n  for (; i < this.labels.length; ++i) {\n    let lab = this.labels[i]\n    if (node.label == null || lab.name === node.label.name) {\n      if (lab.kind != null && (isBreak || lab.kind === \"loop\")) break\n      if (node.label && isBreak) break\n    }\n  }\n  if (i === this.labels.length) this.raise(node.start, \"Unsyntactic \" + keyword)\n  return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\")\n}\n\npp.parseDebuggerStatement = function(node) {\n  this.next()\n  this.semicolon()\n  return this.finishNode(node, \"DebuggerStatement\")\n}\n\npp.parseDoStatement = function(node) {\n  this.next()\n  this.labels.push(loopLabel)\n  node.body = this.parseStatement(\"do\")\n  this.labels.pop()\n  this.expect(tt._while)\n  node.test = this.parseParenExpression()\n  if (this.options.ecmaVersion >= 6)\n    this.eat(tt.semi)\n  else\n    this.semicolon()\n  return this.finishNode(node, \"DoWhileStatement\")\n}\n\n// Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n// loop is non-trivial. Basically, we have to parse the init `var`\n// statement or expression, disallowing the `in` operator (see\n// the second parameter to `parseExpression`), and then check\n// whether the next token is `in` or `of`. When there is no init\n// part (semicolon immediately after the opening parenthesis), it\n// is a regular `for` loop.\n\npp.parseForStatement = function(node) {\n  this.next()\n  let awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual(\"await\")) ? this.lastTokStart : -1\n  this.labels.push(loopLabel)\n  this.enterScope(0)\n  this.expect(tt.parenL)\n  if (this.type === tt.semi) {\n    if (awaitAt > -1) this.unexpected(awaitAt)\n    return this.parseFor(node, null)\n  }\n  let isLet = this.isLet()\n  if (this.type === tt._var || this.type === tt._const || isLet) {\n    let init = this.startNode(), kind = isLet ? \"let\" : this.value\n    this.next()\n    this.parseVar(init, true, kind)\n    this.finishNode(init, \"VariableDeclaration\")\n    if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) && init.declarations.length === 1 &&\n        !(kind !== \"var\" && init.declarations[0].init)) {\n      if (this.options.ecmaVersion >= 9) {\n        if (this.type === tt._in) {\n          if (awaitAt > -1) this.unexpected(awaitAt)\n        } else node.await = awaitAt > -1\n      }\n      return this.parseForIn(node, init)\n    }\n    if (awaitAt > -1) this.unexpected(awaitAt)\n    return this.parseFor(node, init)\n  }\n  let refDestructuringErrors = new DestructuringErrors\n  let init = this.parseExpression(true, refDestructuringErrors)\n  if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) {\n    if (this.options.ecmaVersion >= 9) {\n      if (this.type === tt._in) {\n        if (awaitAt > -1) this.unexpected(awaitAt)\n      } else node.await = awaitAt > -1\n    }\n    this.toAssignable(init, false, refDestructuringErrors)\n    this.checkLVal(init)\n    return this.parseForIn(node, init)\n  } else {\n    this.checkExpressionErrors(refDestructuringErrors, true)\n  }\n  if (awaitAt > -1) this.unexpected(awaitAt)\n  return this.parseFor(node, init)\n}\n\npp.parseFunctionStatement = function(node, isAsync, declarationPosition) {\n  this.next()\n  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)\n}\n\npp.parseIfStatement = function(node) {\n  this.next()\n  node.test = this.parseParenExpression()\n  // allow function declarations in branches, but only in non-strict mode\n  node.consequent = this.parseStatement(\"if\")\n  node.alternate = this.eat(tt._else) ? this.parseStatement(\"if\") : null\n  return this.finishNode(node, \"IfStatement\")\n}\n\npp.parseReturnStatement = function(node) {\n  if (!this.inFunction && !this.options.allowReturnOutsideFunction)\n    this.raise(this.start, \"'return' outside of function\")\n  this.next()\n\n  // In `return` (and `break`/`continue`), the keywords with\n  // optional arguments, we eagerly look for a semicolon or the\n  // possibility to insert one.\n\n  if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null\n  else { node.argument = this.parseExpression(); this.semicolon() }\n  return this.finishNode(node, \"ReturnStatement\")\n}\n\npp.parseSwitchStatement = function(node) {\n  this.next()\n  node.discriminant = this.parseParenExpression()\n  node.cases = []\n  this.expect(tt.braceL)\n  this.labels.push(switchLabel)\n  this.enterScope(0)\n\n  // Statements under must be grouped (by label) in SwitchCase\n  // nodes. `cur` is used to keep the node that we are currently\n  // adding statements to.\n\n  let cur\n  for (let sawDefault = false; this.type !== tt.braceR;) {\n    if (this.type === tt._case || this.type === tt._default) {\n      let isCase = this.type === tt._case\n      if (cur) this.finishNode(cur, \"SwitchCase\")\n      node.cases.push(cur = this.startNode())\n      cur.consequent = []\n      this.next()\n      if (isCase) {\n        cur.test = this.parseExpression()\n      } else {\n        if (sawDefault) this.raiseRecoverable(this.lastTokStart, \"Multiple default clauses\")\n        sawDefault = true\n        cur.test = null\n      }\n      this.expect(tt.colon)\n    } else {\n      if (!cur) this.unexpected()\n      cur.consequent.push(this.parseStatement(null))\n    }\n  }\n  this.exitScope()\n  if (cur) this.finishNode(cur, \"SwitchCase\")\n  this.next() // Closing brace\n  this.labels.pop()\n  return this.finishNode(node, \"SwitchStatement\")\n}\n\npp.parseThrowStatement = function(node) {\n  this.next()\n  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))\n    this.raise(this.lastTokEnd, \"Illegal newline after throw\")\n  node.argument = this.parseExpression()\n  this.semicolon()\n  return this.finishNode(node, \"ThrowStatement\")\n}\n\n// Reused empty array added for node fields that are always empty.\n\nconst empty = []\n\npp.parseTryStatement = function(node) {\n  this.next()\n  node.block = this.parseBlock()\n  node.handler = null\n  if (this.type === tt._catch) {\n    let clause = this.startNode()\n    this.next()\n    if (this.eat(tt.parenL)) {\n      clause.param = this.parseBindingAtom()\n      let simple = clause.param.type === \"Identifier\"\n      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0)\n      this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL)\n      this.expect(tt.parenR)\n    } else {\n      if (this.options.ecmaVersion < 10) this.unexpected()\n      clause.param = null\n      this.enterScope(0)\n    }\n    clause.body = this.parseBlock(false)\n    this.exitScope()\n    node.handler = this.finishNode(clause, \"CatchClause\")\n  }\n  node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null\n  if (!node.handler && !node.finalizer)\n    this.raise(node.start, \"Missing catch or finally clause\")\n  return this.finishNode(node, \"TryStatement\")\n}\n\npp.parseVarStatement = function(node, kind) {\n  this.next()\n  this.parseVar(node, false, kind)\n  this.semicolon()\n  return this.finishNode(node, \"VariableDeclaration\")\n}\n\npp.parseWhileStatement = function(node) {\n  this.next()\n  node.test = this.parseParenExpression()\n  this.labels.push(loopLabel)\n  node.body = this.parseStatement(\"while\")\n  this.labels.pop()\n  return this.finishNode(node, \"WhileStatement\")\n}\n\npp.parseWithStatement = function(node) {\n  if (this.strict) this.raise(this.start, \"'with' in strict mode\")\n  this.next()\n  node.object = this.parseParenExpression()\n  node.body = this.parseStatement(\"with\")\n  return this.finishNode(node, \"WithStatement\")\n}\n\npp.parseEmptyStatement = function(node) {\n  this.next()\n  return this.finishNode(node, \"EmptyStatement\")\n}\n\npp.parseLabeledStatement = function(node, maybeName, expr, context) {\n  for (let label of this.labels)\n    if (label.name === maybeName)\n      this.raise(expr.start, \"Label '\" + maybeName + \"' is already declared\")\n  let kind = this.type.isLoop ? \"loop\" : this.type === tt._switch ? \"switch\" : null\n  for (let i = this.labels.length - 1; i >= 0; i--) {\n    let label = this.labels[i]\n    if (label.statementStart === node.start) {\n      // Update information about previous labels on this node\n      label.statementStart = this.start\n      label.kind = kind\n    } else break\n  }\n  this.labels.push({name: maybeName, kind, statementStart: this.start})\n  node.body = this.parseStatement(context ? context.indexOf(\"label\") === -1 ? context + \"label\" : context : \"label\")\n  this.labels.pop()\n  node.label = expr\n  return this.finishNode(node, \"LabeledStatement\")\n}\n\npp.parseExpressionStatement = function(node, expr) {\n  node.expression = expr\n  this.semicolon()\n  return this.finishNode(node, \"ExpressionStatement\")\n}\n\n// Parse a semicolon-enclosed block of statements, handling `\"use\n// strict\"` declarations when `allowStrict` is true (used for\n// function bodies).\n\npp.parseBlock = function(createNewLexicalScope = true, node = this.startNode()) {\n  node.body = []\n  this.expect(tt.braceL)\n  if (createNewLexicalScope) this.enterScope(0)\n  while (!this.eat(tt.braceR)) {\n    let stmt = this.parseStatement(null)\n    node.body.push(stmt)\n  }\n  if (createNewLexicalScope) this.exitScope()\n  return this.finishNode(node, \"BlockStatement\")\n}\n\n// Parse a regular `for` loop. The disambiguation code in\n// `parseStatement` will already have parsed the init statement or\n// expression.\n\npp.parseFor = function(node, init) {\n  node.init = init\n  this.expect(tt.semi)\n  node.test = this.type === tt.semi ? null : this.parseExpression()\n  this.expect(tt.semi)\n  node.update = this.type === tt.parenR ? null : this.parseExpression()\n  this.expect(tt.parenR)\n  node.body = this.parseStatement(\"for\")\n  this.exitScope()\n  this.labels.pop()\n  return this.finishNode(node, \"ForStatement\")\n}\n\n// Parse a `for`/`in` and `for`/`of` loop, which are almost\n// same from parser's perspective.\n\npp.parseForIn = function(node, init) {\n  let type = this.type === tt._in ? \"ForInStatement\" : \"ForOfStatement\"\n  this.next()\n  if (type === \"ForInStatement\") {\n    if (init.type === \"AssignmentPattern\" ||\n      (init.type === \"VariableDeclaration\" && init.declarations[0].init != null &&\n       (this.strict || init.declarations[0].id.type !== \"Identifier\")))\n      this.raise(init.start, \"Invalid assignment in for-in loop head\")\n  }\n  node.left = init\n  node.right = type === \"ForInStatement\" ? this.parseExpression() : this.parseMaybeAssign()\n  this.expect(tt.parenR)\n  node.body = this.parseStatement(\"for\")\n  this.exitScope()\n  this.labels.pop()\n  return this.finishNode(node, type)\n}\n\n// Parse a list of variable declarations.\n\npp.parseVar = function(node, isFor, kind) {\n  node.declarations = []\n  node.kind = kind\n  for (;;) {\n    let decl = this.startNode()\n    this.parseVarId(decl, kind)\n    if (this.eat(tt.eq)) {\n      decl.init = this.parseMaybeAssign(isFor)\n    } else if (kind === \"const\" && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\")))) {\n      this.unexpected()\n    } else if (decl.id.type !== \"Identifier\" && !(isFor && (this.type === tt._in || this.isContextual(\"of\")))) {\n      this.raise(this.lastTokEnd, \"Complex binding patterns require an initialization value\")\n    } else {\n      decl.init = null\n    }\n    node.declarations.push(this.finishNode(decl, \"VariableDeclarator\"))\n    if (!this.eat(tt.comma)) break\n  }\n  return node\n}\n\npp.parseVarId = function(decl, kind) {\n  if ((kind === \"const\" || kind === \"let\") && this.isContextual(\"let\")) {\n    this.raiseRecoverable(this.start, \"let is disallowed as a lexically bound name\")\n  }\n  decl.id = this.parseBindingAtom()\n  this.checkLVal(decl.id, kind === \"var\" ? BIND_VAR : BIND_LEXICAL, false)\n}\n\nconst FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4\n\n// Parse a function declaration or literal (depending on the\n// `statement & FUNC_STATEMENT`).\n\n// Remove `allowExpressionBody` for 7.0.0, as it is only called with false\npp.parseFunction = function(node, statement, allowExpressionBody, isAsync) {\n  this.initFunction(node)\n  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {\n    if (this.type === tt.star && (statement & FUNC_HANGING_STATEMENT))\n      this.unexpected()\n    node.generator = this.eat(tt.star)\n  }\n  if (this.options.ecmaVersion >= 8)\n    node.async = !!isAsync\n\n  if (statement & FUNC_STATEMENT) {\n    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== tt.name ? null : this.parseIdent()\n    if (node.id && !(statement & FUNC_HANGING_STATEMENT))\n      // If it is a regular function declaration in sloppy mode, then it is\n      // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding\n      // mode depends on properties of the current scope (see\n      // treatFunctionsAsVar).\n      this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION)\n  }\n\n  let oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n  this.yieldPos = 0\n  this.awaitPos = 0\n  this.awaitIdentPos = 0\n  this.enterScope(functionFlags(node.async, node.generator))\n\n  if (!(statement & FUNC_STATEMENT))\n    node.id = this.type === tt.name ? this.parseIdent() : null\n\n  this.parseFunctionParams(node)\n  this.parseFunctionBody(node, allowExpressionBody, false)\n\n  this.yieldPos = oldYieldPos\n  this.awaitPos = oldAwaitPos\n  this.awaitIdentPos = oldAwaitIdentPos\n  return this.finishNode(node, (statement & FUNC_STATEMENT) ? \"FunctionDeclaration\" : \"FunctionExpression\")\n}\n\npp.parseFunctionParams = function(node) {\n  this.expect(tt.parenL)\n  node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8)\n  this.checkYieldAwaitInDefaultParams()\n}\n\n// Parse a class declaration or literal (depending on the\n// `isStatement` parameter).\n\npp.parseClass = function(node, isStatement) {\n  this.next()\n\n  // ecma-262 14.6 Class Definitions\n  // A class definition is always strict mode code.\n  const oldStrict = this.strict\n  this.strict = true\n\n  this.parseClassId(node, isStatement)\n  this.parseClassSuper(node)\n  let classBody = this.startNode()\n  let hadConstructor = false\n  classBody.body = []\n  this.expect(tt.braceL)\n  while (!this.eat(tt.braceR)) {\n    const element = this.parseClassElement(node.superClass !== null)\n    if (element) {\n      classBody.body.push(element)\n      if (element.type === \"MethodDefinition\" && element.kind === \"constructor\") {\n        if (hadConstructor) this.raise(element.start, \"Duplicate constructor in the same class\")\n        hadConstructor = true\n      }\n    }\n  }\n  node.body = this.finishNode(classBody, \"ClassBody\")\n  this.strict = oldStrict\n  return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\")\n}\n\npp.parseClassElement = function(constructorAllowsSuper) {\n  if (this.eat(tt.semi)) return null\n\n  let method = this.startNode()\n  const tryContextual = (k, noLineBreak = false) => {\n    const start = this.start, startLoc = this.startLoc\n    if (!this.eatContextual(k)) return false\n    if (this.type !== tt.parenL && (!noLineBreak || !this.canInsertSemicolon())) return true\n    if (method.key) this.unexpected()\n    method.computed = false\n    method.key = this.startNodeAt(start, startLoc)\n    method.key.name = k\n    this.finishNode(method.key, \"Identifier\")\n    return false\n  }\n\n  method.kind = \"method\"\n  method.static = tryContextual(\"static\")\n  let isGenerator = this.eat(tt.star)\n  let isAsync = false\n  if (!isGenerator) {\n    if (this.options.ecmaVersion >= 8 && tryContextual(\"async\", true)) {\n      isAsync = true\n      isGenerator = this.options.ecmaVersion >= 9 && this.eat(tt.star)\n    } else if (tryContextual(\"get\")) {\n      method.kind = \"get\"\n    } else if (tryContextual(\"set\")) {\n      method.kind = \"set\"\n    }\n  }\n  if (!method.key) this.parsePropertyName(method)\n  let {key} = method\n  let allowsDirectSuper = false\n  if (!method.computed && !method.static && (key.type === \"Identifier\" && key.name === \"constructor\" ||\n      key.type === \"Literal\" && key.value === \"constructor\")) {\n    if (method.kind !== \"method\") this.raise(key.start, \"Constructor can't have get/set modifier\")\n    if (isGenerator) this.raise(key.start, \"Constructor can't be a generator\")\n    if (isAsync) this.raise(key.start, \"Constructor can't be an async method\")\n    method.kind = \"constructor\"\n    allowsDirectSuper = constructorAllowsSuper\n  } else if (method.static && key.type === \"Identifier\" && key.name === \"prototype\") {\n    this.raise(key.start, \"Classes may not have a static property named prototype\")\n  }\n  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper)\n  if (method.kind === \"get\" && method.value.params.length !== 0)\n    this.raiseRecoverable(method.value.start, \"getter should have no params\")\n  if (method.kind === \"set\" && method.value.params.length !== 1)\n    this.raiseRecoverable(method.value.start, \"setter should have exactly one param\")\n  if (method.kind === \"set\" && method.value.params[0].type === \"RestElement\")\n    this.raiseRecoverable(method.value.params[0].start, \"Setter cannot use rest params\")\n  return method\n}\n\npp.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {\n  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper)\n  return this.finishNode(method, \"MethodDefinition\")\n}\n\npp.parseClassId = function(node, isStatement) {\n  if (this.type === tt.name) {\n    node.id = this.parseIdent()\n    if (isStatement)\n      this.checkLVal(node.id, BIND_LEXICAL, false)\n  } else {\n    if (isStatement === true)\n      this.unexpected()\n    node.id = null\n  }\n}\n\npp.parseClassSuper = function(node) {\n  node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null\n}\n\n// Parses module export declaration.\n\npp.parseExport = function(node, exports) {\n  this.next()\n  // export * from '...'\n  if (this.eat(tt.star)) {\n    this.expectContextual(\"from\")\n    if (this.type !== tt.string) this.unexpected()\n    node.source = this.parseExprAtom()\n    this.semicolon()\n    return this.finishNode(node, \"ExportAllDeclaration\")\n  }\n  if (this.eat(tt._default)) { // export default ...\n    this.checkExport(exports, \"default\", this.lastTokStart)\n    let isAsync\n    if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {\n      let fNode = this.startNode()\n      this.next()\n      if (isAsync) this.next()\n      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync)\n    } else if (this.type === tt._class) {\n      let cNode = this.startNode()\n      node.declaration = this.parseClass(cNode, \"nullableID\")\n    } else {\n      node.declaration = this.parseMaybeAssign()\n      this.semicolon()\n    }\n    return this.finishNode(node, \"ExportDefaultDeclaration\")\n  }\n  // export var|const|let|function|class ...\n  if (this.shouldParseExportStatement()) {\n    node.declaration = this.parseStatement(null)\n    if (node.declaration.type === \"VariableDeclaration\")\n      this.checkVariableExport(exports, node.declaration.declarations)\n    else\n      this.checkExport(exports, node.declaration.id.name, node.declaration.id.start)\n    node.specifiers = []\n    node.source = null\n  } else { // export { x, y as z } [from '...']\n    node.declaration = null\n    node.specifiers = this.parseExportSpecifiers(exports)\n    if (this.eatContextual(\"from\")) {\n      if (this.type !== tt.string) this.unexpected()\n      node.source = this.parseExprAtom()\n    } else {\n      for (let spec of node.specifiers) {\n        // check for keywords used as local names\n        this.checkUnreserved(spec.local)\n        // check if export is defined\n        this.checkLocalExport(spec.local)\n      }\n\n      node.source = null\n    }\n    this.semicolon()\n  }\n  return this.finishNode(node, \"ExportNamedDeclaration\")\n}\n\npp.checkExport = function(exports, name, pos) {\n  if (!exports) return\n  if (has(exports, name))\n    this.raiseRecoverable(pos, \"Duplicate export '\" + name + \"'\")\n  exports[name] = true\n}\n\npp.checkPatternExport = function(exports, pat) {\n  let type = pat.type\n  if (type === \"Identifier\")\n    this.checkExport(exports, pat.name, pat.start)\n  else if (type === \"ObjectPattern\")\n    for (let prop of pat.properties)\n      this.checkPatternExport(exports, prop)\n  else if (type === \"ArrayPattern\")\n    for (let elt of pat.elements) {\n      if (elt) this.checkPatternExport(exports, elt)\n    }\n  else if (type === \"Property\")\n    this.checkPatternExport(exports, pat.value)\n  else if (type === \"AssignmentPattern\")\n    this.checkPatternExport(exports, pat.left)\n  else if (type === \"RestElement\")\n    this.checkPatternExport(exports, pat.argument)\n  else if (type === \"ParenthesizedExpression\")\n    this.checkPatternExport(exports, pat.expression)\n}\n\npp.checkVariableExport = function(exports, decls) {\n  if (!exports) return\n  for (let decl of decls)\n    this.checkPatternExport(exports, decl.id)\n}\n\npp.shouldParseExportStatement = function() {\n  return this.type.keyword === \"var\" ||\n    this.type.keyword === \"const\" ||\n    this.type.keyword === \"class\" ||\n    this.type.keyword === \"function\" ||\n    this.isLet() ||\n    this.isAsyncFunction()\n}\n\n// Parses a comma-separated list of module exports.\n\npp.parseExportSpecifiers = function(exports) {\n  let nodes = [], first = true\n  // export { x, y as z } [from '...']\n  this.expect(tt.braceL)\n  while (!this.eat(tt.braceR)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (this.afterTrailingComma(tt.braceR)) break\n    } else first = false\n\n    let node = this.startNode()\n    node.local = this.parseIdent(true)\n    node.exported = this.eatContextual(\"as\") ? this.parseIdent(true) : node.local\n    this.checkExport(exports, node.exported.name, node.exported.start)\n    nodes.push(this.finishNode(node, \"ExportSpecifier\"))\n  }\n  return nodes\n}\n\n// Parses import declaration.\n\npp.parseImport = function(node) {\n  this.next()\n  // import '...'\n  if (this.type === tt.string) {\n    node.specifiers = empty\n    node.source = this.parseExprAtom()\n  } else {\n    node.specifiers = this.parseImportSpecifiers()\n    this.expectContextual(\"from\")\n    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()\n  }\n  this.semicolon()\n  return this.finishNode(node, \"ImportDeclaration\")\n}\n\n// Parses a comma-separated list of module imports.\n\npp.parseImportSpecifiers = function() {\n  let nodes = [], first = true\n  if (this.type === tt.name) {\n    // import defaultObj, { x, y as z } from '...'\n    let node = this.startNode()\n    node.local = this.parseIdent()\n    this.checkLVal(node.local, BIND_LEXICAL)\n    nodes.push(this.finishNode(node, \"ImportDefaultSpecifier\"))\n    if (!this.eat(tt.comma)) return nodes\n  }\n  if (this.type === tt.star) {\n    let node = this.startNode()\n    this.next()\n    this.expectContextual(\"as\")\n    node.local = this.parseIdent()\n    this.checkLVal(node.local, BIND_LEXICAL)\n    nodes.push(this.finishNode(node, \"ImportNamespaceSpecifier\"))\n    return nodes\n  }\n  this.expect(tt.braceL)\n  while (!this.eat(tt.braceR)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (this.afterTrailingComma(tt.braceR)) break\n    } else first = false\n\n    let node = this.startNode()\n    node.imported = this.parseIdent(true)\n    if (this.eatContextual(\"as\")) {\n      node.local = this.parseIdent()\n    } else {\n      this.checkUnreserved(node.imported)\n      node.local = node.imported\n    }\n    this.checkLVal(node.local, BIND_LEXICAL)\n    nodes.push(this.finishNode(node, \"ImportSpecifier\"))\n  }\n  return nodes\n}\n\n// Set `ExpressionStatement#directive` property for directive prologues.\npp.adaptDirectivePrologue = function(statements) {\n  for (let i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {\n    statements[i].directive = statements[i].expression.raw.slice(1, -1)\n  }\n}\npp.isDirectiveCandidate = function(statement) {\n  return (\n    statement.type === \"ExpressionStatement\" &&\n    statement.expression.type === \"Literal\" &&\n    typeof statement.expression.value === \"string\" &&\n    // Reject parenthesized strings.\n    (this.input[statement.start] === \"\\\"\" || this.input[statement.start] === \"'\")\n  )\n}\n","import {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {has} from \"./util\"\nimport {BIND_NONE, BIND_OUTSIDE} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\n// Convert existing expression atom to assignable pattern\n// if possible.\n\npp.toAssignable = function(node, isBinding, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 6 && node) {\n    switch (node.type) {\n    case \"Identifier\":\n      if (this.inAsync && node.name === \"await\")\n        this.raise(node.start, \"Cannot use 'await' as identifier inside an async function\")\n      break\n\n    case \"ObjectPattern\":\n    case \"ArrayPattern\":\n    case \"RestElement\":\n      break\n\n    case \"ObjectExpression\":\n      node.type = \"ObjectPattern\"\n      if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true)\n      for (let prop of node.properties) {\n        this.toAssignable(prop, isBinding)\n        // Early error:\n        //   AssignmentRestProperty[Yield, Await] :\n        //     `...` DestructuringAssignmentTarget[Yield, Await]\n        //\n        //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.\n        if (\n          prop.type === \"RestElement\" &&\n          (prop.argument.type === \"ArrayPattern\" || prop.argument.type === \"ObjectPattern\")\n        ) {\n          this.raise(prop.argument.start, \"Unexpected token\")\n        }\n      }\n      break\n\n    case \"Property\":\n      // AssignmentProperty has type === \"Property\"\n      if (node.kind !== \"init\") this.raise(node.key.start, \"Object pattern can't contain getter or setter\")\n      this.toAssignable(node.value, isBinding)\n      break\n\n    case \"ArrayExpression\":\n      node.type = \"ArrayPattern\"\n      if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true)\n      this.toAssignableList(node.elements, isBinding)\n      break\n\n    case \"SpreadElement\":\n      node.type = \"RestElement\"\n      this.toAssignable(node.argument, isBinding)\n      if (node.argument.type === \"AssignmentPattern\")\n        this.raise(node.argument.start, \"Rest elements cannot have a default value\")\n      break\n\n    case \"AssignmentExpression\":\n      if (node.operator !== \"=\") this.raise(node.left.end, \"Only '=' operator can be used for specifying default value.\")\n      node.type = \"AssignmentPattern\"\n      delete node.operator\n      this.toAssignable(node.left, isBinding)\n      // falls through to AssignmentPattern\n\n    case \"AssignmentPattern\":\n      break\n\n    case \"ParenthesizedExpression\":\n      this.toAssignable(node.expression, isBinding, refDestructuringErrors)\n      break\n\n    case \"MemberExpression\":\n      if (!isBinding) break\n\n    default:\n      this.raise(node.start, \"Assigning to rvalue\")\n    }\n  } else if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true)\n  return node\n}\n\n// Convert list of expression atoms to binding list.\n\npp.toAssignableList = function(exprList, isBinding) {\n  let end = exprList.length\n  for (let i = 0; i < end; i++) {\n    let elt = exprList[i]\n    if (elt) this.toAssignable(elt, isBinding)\n  }\n  if (end) {\n    let last = exprList[end - 1]\n    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === \"RestElement\" && last.argument.type !== \"Identifier\")\n      this.unexpected(last.argument.start)\n  }\n  return exprList\n}\n\n// Parses spread element.\n\npp.parseSpread = function(refDestructuringErrors) {\n  let node = this.startNode()\n  this.next()\n  node.argument = this.parseMaybeAssign(false, refDestructuringErrors)\n  return this.finishNode(node, \"SpreadElement\")\n}\n\npp.parseRestBinding = function() {\n  let node = this.startNode()\n  this.next()\n\n  // RestElement inside of a function parameter must be an identifier\n  if (this.options.ecmaVersion === 6 && this.type !== tt.name)\n    this.unexpected()\n\n  node.argument = this.parseBindingAtom()\n\n  return this.finishNode(node, \"RestElement\")\n}\n\n// Parses lvalue (assignable) atom.\n\npp.parseBindingAtom = function() {\n  if (this.options.ecmaVersion >= 6) {\n    switch (this.type) {\n    case tt.bracketL:\n      let node = this.startNode()\n      this.next()\n      node.elements = this.parseBindingList(tt.bracketR, true, true)\n      return this.finishNode(node, \"ArrayPattern\")\n\n    case tt.braceL:\n      return this.parseObj(true)\n    }\n  }\n  return this.parseIdent()\n}\n\npp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {\n  let elts = [], first = true\n  while (!this.eat(close)) {\n    if (first) first = false\n    else this.expect(tt.comma)\n    if (allowEmpty && this.type === tt.comma) {\n      elts.push(null)\n    } else if (allowTrailingComma && this.afterTrailingComma(close)) {\n      break\n    } else if (this.type === tt.ellipsis) {\n      let rest = this.parseRestBinding()\n      this.parseBindingListItem(rest)\n      elts.push(rest)\n      if (this.type === tt.comma) this.raise(this.start, \"Comma is not permitted after the rest element\")\n      this.expect(close)\n      break\n    } else {\n      let elem = this.parseMaybeDefault(this.start, this.startLoc)\n      this.parseBindingListItem(elem)\n      elts.push(elem)\n    }\n  }\n  return elts\n}\n\npp.parseBindingListItem = function(param) {\n  return param\n}\n\n// Parses assignment pattern around given atom if possible.\n\npp.parseMaybeDefault = function(startPos, startLoc, left) {\n  left = left || this.parseBindingAtom()\n  if (this.options.ecmaVersion < 6 || !this.eat(tt.eq)) return left\n  let node = this.startNodeAt(startPos, startLoc)\n  node.left = left\n  node.right = this.parseMaybeAssign()\n  return this.finishNode(node, \"AssignmentPattern\")\n}\n\n// Verify that a node is an lval — something that can be assigned\n// to.\n// bindingType can be either:\n// 'var' indicating that the lval creates a 'var' binding\n// 'let' indicating that the lval creates a lexical ('let' or 'const') binding\n// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references\n\npp.checkLVal = function(expr, bindingType = BIND_NONE, checkClashes) {\n  switch (expr.type) {\n  case \"Identifier\":\n    if (this.strict && this.reservedWordsStrictBind.test(expr.name))\n      this.raiseRecoverable(expr.start, (bindingType ? \"Binding \" : \"Assigning to \") + expr.name + \" in strict mode\")\n    if (checkClashes) {\n      if (has(checkClashes, expr.name))\n        this.raiseRecoverable(expr.start, \"Argument name clash\")\n      checkClashes[expr.name] = true\n    }\n    if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) this.declareName(expr.name, bindingType, expr.start)\n    break\n\n  case \"MemberExpression\":\n    if (bindingType) this.raiseRecoverable(expr.start, \"Binding member expression\")\n    break\n\n  case \"ObjectPattern\":\n    for (let prop of expr.properties)\n      this.checkLVal(prop, bindingType, checkClashes)\n    break\n\n  case \"Property\":\n    // AssignmentProperty has type === \"Property\"\n    this.checkLVal(expr.value, bindingType, checkClashes)\n    break\n\n  case \"ArrayPattern\":\n    for (let elem of expr.elements) {\n      if (elem) this.checkLVal(elem, bindingType, checkClashes)\n    }\n    break\n\n  case \"AssignmentPattern\":\n    this.checkLVal(expr.left, bindingType, checkClashes)\n    break\n\n  case \"RestElement\":\n    this.checkLVal(expr.argument, bindingType, checkClashes)\n    break\n\n  case \"ParenthesizedExpression\":\n    this.checkLVal(expr.expression, bindingType, checkClashes)\n    break\n\n  default:\n    this.raise(expr.start, (bindingType ? \"Binding\" : \"Assigning to\") + \" rvalue\")\n  }\n}\n","// A recursive descent parser operates by defining functions for all\n// syntactic elements, and recursively calling those, each function\n// advancing the input stream and returning an AST node. Precedence\n// of constructs (for example, the fact that `!x[1]` means `!(x[1])`\n// instead of `(!x)[1]` is handled by the fact that the parser\n// function that parses unary prefix operators is called first, and\n// in turn calls the function that parses `[]` subscripts — that\n// way, it'll receive the node for `x[1]` already parsed, and wraps\n// *that* in the unary operator node.\n//\n// Acorn uses an [operator precedence parser][opp] to handle binary\n// operator precedence, because it is much more compact than using\n// the technique outlined above, which uses different, nesting\n// functions to specify precedence, for all of the ten binary\n// precedence levels that JavaScript defines.\n//\n// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser\n\nimport {types as tt} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {DestructuringErrors} from \"./parseutil\"\nimport {lineBreak} from \"./whitespace\"\nimport {functionFlags, SCOPE_ARROW, SCOPE_SUPER, SCOPE_DIRECT_SUPER, BIND_OUTSIDE, BIND_VAR} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\n// Check if property name clashes with already added.\n// Object/class getters and setters are not allowed to clash —\n// either with each other or with an init property — and in\n// strict mode, init properties are also not allowed to be repeated.\n\npp.checkPropClash = function(prop, propHash, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 9 && prop.type === \"SpreadElement\")\n    return\n  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))\n    return\n  let {key} = prop, name\n  switch (key.type) {\n  case \"Identifier\": name = key.name; break\n  case \"Literal\": name = String(key.value); break\n  default: return\n  }\n  let {kind} = prop\n  if (this.options.ecmaVersion >= 6) {\n    if (name === \"__proto__\" && kind === \"init\") {\n      if (propHash.proto) {\n        if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) refDestructuringErrors.doubleProto = key.start\n        // Backwards-compat kludge. Can be removed in version 6.0\n        else this.raiseRecoverable(key.start, \"Redefinition of __proto__ property\")\n      }\n      propHash.proto = true\n    }\n    return\n  }\n  name = \"$\" + name\n  let other = propHash[name]\n  if (other) {\n    let redefinition\n    if (kind === \"init\") {\n      redefinition = this.strict && other.init || other.get || other.set\n    } else {\n      redefinition = other.init || other[kind]\n    }\n    if (redefinition)\n      this.raiseRecoverable(key.start, \"Redefinition of property\")\n  } else {\n    other = propHash[name] = {\n      init: false,\n      get: false,\n      set: false\n    }\n  }\n  other[kind] = true\n}\n\n// ### Expression parsing\n\n// These nest, from the most general expression type at the top to\n// 'atomic', nondivisible expression types at the bottom. Most of\n// the functions will simply let the function(s) below them parse,\n// and, *if* the syntactic construct they handle is present, wrap\n// the AST node that the inner parser gave them in another node.\n\n// Parse a full expression. The optional arguments are used to\n// forbid the `in` operator (in for loops initalization expressions)\n// and provide reference for storing '=' operator inside shorthand\n// property assignment in contexts where both object expression\n// and object pattern might appear (so it's possible to raise\n// delayed syntax error at correct position).\n\npp.parseExpression = function(noIn, refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseMaybeAssign(noIn, refDestructuringErrors)\n  if (this.type === tt.comma) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.expressions = [expr]\n    while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors))\n    return this.finishNode(node, \"SequenceExpression\")\n  }\n  return expr\n}\n\n// Parse an assignment expression. This includes applications of\n// operators like `+=`.\n\npp.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {\n  if (this.isContextual(\"yield\")) {\n    if (this.inGenerator) return this.parseYield(noIn)\n    // The tokenizer will assume an expression is allowed after\n    // `yield`, but this isn't that kind of yield\n    else this.exprAllowed = false\n  }\n\n  let ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldShorthandAssign = -1\n  if (refDestructuringErrors) {\n    oldParenAssign = refDestructuringErrors.parenthesizedAssign\n    oldTrailingComma = refDestructuringErrors.trailingComma\n    oldShorthandAssign = refDestructuringErrors.shorthandAssign\n    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.shorthandAssign = -1\n  } else {\n    refDestructuringErrors = new DestructuringErrors\n    ownDestructuringErrors = true\n  }\n\n  let startPos = this.start, startLoc = this.startLoc\n  if (this.type === tt.parenL || this.type === tt.name)\n    this.potentialArrowAt = this.start\n  let left = this.parseMaybeConditional(noIn, refDestructuringErrors)\n  if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc)\n  if (this.type.isAssign) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.operator = this.value\n    node.left = this.type === tt.eq ? this.toAssignable(left, false, refDestructuringErrors) : left\n    if (!ownDestructuringErrors) DestructuringErrors.call(refDestructuringErrors)\n    refDestructuringErrors.shorthandAssign = -1 // reset because shorthand default was used correctly\n    this.checkLVal(left)\n    this.next()\n    node.right = this.parseMaybeAssign(noIn)\n    return this.finishNode(node, \"AssignmentExpression\")\n  } else {\n    if (ownDestructuringErrors) this.checkExpressionErrors(refDestructuringErrors, true)\n  }\n  if (oldParenAssign > -1) refDestructuringErrors.parenthesizedAssign = oldParenAssign\n  if (oldTrailingComma > -1) refDestructuringErrors.trailingComma = oldTrailingComma\n  if (oldShorthandAssign > -1) refDestructuringErrors.shorthandAssign = oldShorthandAssign\n  return left\n}\n\n// Parse a ternary conditional (`?:`) operator.\n\npp.parseMaybeConditional = function(noIn, refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseExprOps(noIn, refDestructuringErrors)\n  if (this.checkExpressionErrors(refDestructuringErrors)) return expr\n  if (this.eat(tt.question)) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.test = expr\n    node.consequent = this.parseMaybeAssign()\n    this.expect(tt.colon)\n    node.alternate = this.parseMaybeAssign(noIn)\n    return this.finishNode(node, \"ConditionalExpression\")\n  }\n  return expr\n}\n\n// Start the precedence parser.\n\npp.parseExprOps = function(noIn, refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseMaybeUnary(refDestructuringErrors, false)\n  if (this.checkExpressionErrors(refDestructuringErrors)) return expr\n  return expr.start === startPos && expr.type === \"ArrowFunctionExpression\" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)\n}\n\n// Parse binary operators with the operator precedence parsing\n// algorithm. `left` is the left-hand side of the operator.\n// `minPrec` provides context that allows the function to stop and\n// defer further parser to one of its callers when it encounters an\n// operator that has a lower precedence than the set it is parsing.\n\npp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {\n  let prec = this.type.binop\n  if (prec != null && (!noIn || this.type !== tt._in)) {\n    if (prec > minPrec) {\n      let logical = this.type === tt.logicalOR || this.type === tt.logicalAND\n      let op = this.value\n      this.next()\n      let startPos = this.start, startLoc = this.startLoc\n      let right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn)\n      let node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical)\n      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)\n    }\n  }\n  return left\n}\n\npp.buildBinary = function(startPos, startLoc, left, right, op, logical) {\n  let node = this.startNodeAt(startPos, startLoc)\n  node.left = left\n  node.operator = op\n  node.right = right\n  return this.finishNode(node, logical ? \"LogicalExpression\" : \"BinaryExpression\")\n}\n\n// Parse unary operators, both prefix and postfix.\n\npp.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {\n  let startPos = this.start, startLoc = this.startLoc, expr\n  if (this.isContextual(\"await\") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {\n    expr = this.parseAwait()\n    sawUnary = true\n  } else if (this.type.prefix) {\n    let node = this.startNode(), update = this.type === tt.incDec\n    node.operator = this.value\n    node.prefix = true\n    this.next()\n    node.argument = this.parseMaybeUnary(null, true)\n    this.checkExpressionErrors(refDestructuringErrors, true)\n    if (update) this.checkLVal(node.argument)\n    else if (this.strict && node.operator === \"delete\" &&\n             node.argument.type === \"Identifier\")\n      this.raiseRecoverable(node.start, \"Deleting local variable in strict mode\")\n    else sawUnary = true\n    expr = this.finishNode(node, update ? \"UpdateExpression\" : \"UnaryExpression\")\n  } else {\n    expr = this.parseExprSubscripts(refDestructuringErrors)\n    if (this.checkExpressionErrors(refDestructuringErrors)) return expr\n    while (this.type.postfix && !this.canInsertSemicolon()) {\n      let node = this.startNodeAt(startPos, startLoc)\n      node.operator = this.value\n      node.prefix = false\n      node.argument = expr\n      this.checkLVal(expr)\n      this.next()\n      expr = this.finishNode(node, \"UpdateExpression\")\n    }\n  }\n\n  if (!sawUnary && this.eat(tt.starstar))\n    return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), \"**\", false)\n  else\n    return expr\n}\n\n// Parse call, dot, and `[]`-subscript expressions.\n\npp.parseExprSubscripts = function(refDestructuringErrors) {\n  let startPos = this.start, startLoc = this.startLoc\n  let expr = this.parseExprAtom(refDestructuringErrors)\n  let skipArrowSubscripts = expr.type === \"ArrowFunctionExpression\" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== \")\"\n  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) return expr\n  let result = this.parseSubscripts(expr, startPos, startLoc)\n  if (refDestructuringErrors && result.type === \"MemberExpression\") {\n    if (refDestructuringErrors.parenthesizedAssign >= result.start) refDestructuringErrors.parenthesizedAssign = -1\n    if (refDestructuringErrors.parenthesizedBind >= result.start) refDestructuringErrors.parenthesizedBind = -1\n  }\n  return result\n}\n\npp.parseSubscripts = function(base, startPos, startLoc, noCalls) {\n  let maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === \"Identifier\" && base.name === \"async\" &&\n      this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === \"async\"\n  while (true) {\n    let element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow)\n    if (element === base || element.type === \"ArrowFunctionExpression\") return element\n    base = element\n  }\n}\n\npp.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {\n  let computed = this.eat(tt.bracketL)\n  if (computed || this.eat(tt.dot)) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.object = base\n    node.property = computed ? this.parseExpression() : this.parseIdent(true)\n    node.computed = !!computed\n    if (computed) this.expect(tt.bracketR)\n    base = this.finishNode(node, \"MemberExpression\")\n  } else if (!noCalls && this.eat(tt.parenL)) {\n    let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n    this.yieldPos = 0\n    this.awaitPos = 0\n    this.awaitIdentPos = 0\n    let exprList = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors)\n    if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false)\n      this.checkYieldAwaitInDefaultParams()\n      if (this.awaitIdentPos > 0)\n        this.raise(this.awaitIdentPos, \"Cannot use 'await' as identifier inside an async function\")\n      this.yieldPos = oldYieldPos\n      this.awaitPos = oldAwaitPos\n      this.awaitIdentPos = oldAwaitIdentPos\n      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)\n    }\n    this.checkExpressionErrors(refDestructuringErrors, true)\n    this.yieldPos = oldYieldPos || this.yieldPos\n    this.awaitPos = oldAwaitPos || this.awaitPos\n    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos\n    let node = this.startNodeAt(startPos, startLoc)\n    node.callee = base\n    node.arguments = exprList\n    base = this.finishNode(node, \"CallExpression\")\n  } else if (this.type === tt.backQuote) {\n    let node = this.startNodeAt(startPos, startLoc)\n    node.tag = base\n    node.quasi = this.parseTemplate({isTagged: true})\n    base = this.finishNode(node, \"TaggedTemplateExpression\")\n  }\n  return base\n}\n\n// Parse an atomic expression — either a single token that is an\n// expression, an expression started by a keyword like `function` or\n// `new`, or an expression wrapped in punctuation like `()`, `[]`,\n// or `{}`.\n\npp.parseExprAtom = function(refDestructuringErrors) {\n  // If a division operator appears in an expression position, the\n  // tokenizer got confused, and we force it to read a regexp instead.\n  if (this.type === tt.slash) this.readRegexp()\n\n  let node, canBeArrow = this.potentialArrowAt === this.start\n  switch (this.type) {\n  case tt._super:\n    if (!this.allowSuper)\n      this.raise(this.start, \"'super' keyword outside a method\")\n    node = this.startNode()\n    this.next()\n    if (this.type === tt.parenL && !this.allowDirectSuper)\n      this.raise(node.start, \"super() call outside constructor of a subclass\")\n    // The `super` keyword can appear at below:\n    // SuperProperty:\n    //     super [ Expression ]\n    //     super . IdentifierName\n    // SuperCall:\n    //     super Arguments\n    if (this.type !== tt.dot && this.type !== tt.bracketL && this.type !== tt.parenL)\n      this.unexpected()\n    return this.finishNode(node, \"Super\")\n\n  case tt._this:\n    node = this.startNode()\n    this.next()\n    return this.finishNode(node, \"ThisExpression\")\n\n  case tt.name:\n    let startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc\n    let id = this.parseIdent(false)\n    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === \"async\" && !this.canInsertSemicolon() && this.eat(tt._function))\n      return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true)\n    if (canBeArrow && !this.canInsertSemicolon()) {\n      if (this.eat(tt.arrow))\n        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false)\n      if (this.options.ecmaVersion >= 8 && id.name === \"async\" && this.type === tt.name && !containsEsc) {\n        id = this.parseIdent(false)\n        if (this.canInsertSemicolon() || !this.eat(tt.arrow))\n          this.unexpected()\n        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)\n      }\n    }\n    return id\n\n  case tt.regexp:\n    let value = this.value\n    node = this.parseLiteral(value.value)\n    node.regex = {pattern: value.pattern, flags: value.flags}\n    return node\n\n  case tt.num: case tt.string:\n    return this.parseLiteral(this.value)\n\n  case tt._null: case tt._true: case tt._false:\n    node = this.startNode()\n    node.value = this.type === tt._null ? null : this.type === tt._true\n    node.raw = this.type.keyword\n    this.next()\n    return this.finishNode(node, \"Literal\")\n\n  case tt.parenL:\n    let start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow)\n    if (refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))\n        refDestructuringErrors.parenthesizedAssign = start\n      if (refDestructuringErrors.parenthesizedBind < 0)\n        refDestructuringErrors.parenthesizedBind = start\n    }\n    return expr\n\n  case tt.bracketL:\n    node = this.startNode()\n    this.next()\n    node.elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors)\n    return this.finishNode(node, \"ArrayExpression\")\n\n  case tt.braceL:\n    return this.parseObj(false, refDestructuringErrors)\n\n  case tt._function:\n    node = this.startNode()\n    this.next()\n    return this.parseFunction(node, 0)\n\n  case tt._class:\n    return this.parseClass(this.startNode(), false)\n\n  case tt._new:\n    return this.parseNew()\n\n  case tt.backQuote:\n    return this.parseTemplate()\n\n  default:\n    this.unexpected()\n  }\n}\n\npp.parseLiteral = function(value) {\n  let node = this.startNode()\n  node.value = value\n  node.raw = this.input.slice(this.start, this.end)\n  this.next()\n  return this.finishNode(node, \"Literal\")\n}\n\npp.parseParenExpression = function() {\n  this.expect(tt.parenL)\n  let val = this.parseExpression()\n  this.expect(tt.parenR)\n  return val\n}\n\npp.parseParenAndDistinguishExpression = function(canBeArrow) {\n  let startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8\n  if (this.options.ecmaVersion >= 6) {\n    this.next()\n\n    let innerStartPos = this.start, innerStartLoc = this.startLoc\n    let exprList = [], first = true, lastIsComma = false\n    let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart\n    this.yieldPos = 0\n    this.awaitPos = 0\n    // Do not save awaitIdentPos to allow checking awaits nested in parameters\n    while (this.type !== tt.parenR) {\n      first ? first = false : this.expect(tt.comma)\n      if (allowTrailingComma && this.afterTrailingComma(tt.parenR, true)) {\n        lastIsComma = true\n        break\n      } else if (this.type === tt.ellipsis) {\n        spreadStart = this.start\n        exprList.push(this.parseParenItem(this.parseRestBinding()))\n        if (this.type === tt.comma) this.raise(this.start, \"Comma is not permitted after the rest element\")\n        break\n      } else {\n        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem))\n      }\n    }\n    let innerEndPos = this.start, innerEndLoc = this.startLoc\n    this.expect(tt.parenR)\n\n    if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false)\n      this.checkYieldAwaitInDefaultParams()\n      this.yieldPos = oldYieldPos\n      this.awaitPos = oldAwaitPos\n      return this.parseParenArrowList(startPos, startLoc, exprList)\n    }\n\n    if (!exprList.length || lastIsComma) this.unexpected(this.lastTokStart)\n    if (spreadStart) this.unexpected(spreadStart)\n    this.checkExpressionErrors(refDestructuringErrors, true)\n    this.yieldPos = oldYieldPos || this.yieldPos\n    this.awaitPos = oldAwaitPos || this.awaitPos\n\n    if (exprList.length > 1) {\n      val = this.startNodeAt(innerStartPos, innerStartLoc)\n      val.expressions = exprList\n      this.finishNodeAt(val, \"SequenceExpression\", innerEndPos, innerEndLoc)\n    } else {\n      val = exprList[0]\n    }\n  } else {\n    val = this.parseParenExpression()\n  }\n\n  if (this.options.preserveParens) {\n    let par = this.startNodeAt(startPos, startLoc)\n    par.expression = val\n    return this.finishNode(par, \"ParenthesizedExpression\")\n  } else {\n    return val\n  }\n}\n\npp.parseParenItem = function(item) {\n  return item\n}\n\npp.parseParenArrowList = function(startPos, startLoc, exprList) {\n  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)\n}\n\n// New's precedence is slightly tricky. It must allow its argument to\n// be a `[]` or dot subscript expression, but not a call — at least,\n// not without wrapping it in parentheses. Thus, it uses the noCalls\n// argument to parseSubscripts to prevent it from consuming the\n// argument list.\n\nconst empty = []\n\npp.parseNew = function() {\n  let node = this.startNode()\n  let meta = this.parseIdent(true)\n  if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {\n    node.meta = meta\n    let containsEsc = this.containsEsc\n    node.property = this.parseIdent(true)\n    if (node.property.name !== \"target\" || containsEsc)\n      this.raiseRecoverable(node.property.start, \"The only valid meta property for new is new.target\")\n    if (!this.inNonArrowFunction())\n      this.raiseRecoverable(node.start, \"new.target can only be used in functions\")\n    return this.finishNode(node, \"MetaProperty\")\n  }\n  let startPos = this.start, startLoc = this.startLoc\n  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true)\n  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false)\n  else node.arguments = empty\n  return this.finishNode(node, \"NewExpression\")\n}\n\n// Parse template expression.\n\npp.parseTemplateElement = function({isTagged}) {\n  let elem = this.startNode()\n  if (this.type === tt.invalidTemplate) {\n    if (!isTagged) {\n      this.raiseRecoverable(this.start, \"Bad escape sequence in untagged template literal\")\n    }\n    elem.value = {\n      raw: this.value,\n      cooked: null\n    }\n  } else {\n    elem.value = {\n      raw: this.input.slice(this.start, this.end).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: this.value\n    }\n  }\n  this.next()\n  elem.tail = this.type === tt.backQuote\n  return this.finishNode(elem, \"TemplateElement\")\n}\n\npp.parseTemplate = function({isTagged = false} = {}) {\n  let node = this.startNode()\n  this.next()\n  node.expressions = []\n  let curElt = this.parseTemplateElement({isTagged})\n  node.quasis = [curElt]\n  while (!curElt.tail) {\n    if (this.type === tt.eof) this.raise(this.pos, \"Unterminated template literal\")\n    this.expect(tt.dollarBraceL)\n    node.expressions.push(this.parseExpression())\n    this.expect(tt.braceR)\n    node.quasis.push(curElt = this.parseTemplateElement({isTagged}))\n  }\n  this.next()\n  return this.finishNode(node, \"TemplateLiteral\")\n}\n\npp.isAsyncProp = function(prop) {\n  return !prop.computed && prop.key.type === \"Identifier\" && prop.key.name === \"async\" &&\n    (this.type === tt.name || this.type === tt.num || this.type === tt.string || this.type === tt.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === tt.star)) &&\n    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n}\n\n// Parse an object literal or binding pattern.\n\npp.parseObj = function(isPattern, refDestructuringErrors) {\n  let node = this.startNode(), first = true, propHash = {}\n  node.properties = []\n  this.next()\n  while (!this.eat(tt.braceR)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (this.afterTrailingComma(tt.braceR)) break\n    } else first = false\n\n    const prop = this.parseProperty(isPattern, refDestructuringErrors)\n    if (!isPattern) this.checkPropClash(prop, propHash, refDestructuringErrors)\n    node.properties.push(prop)\n  }\n  return this.finishNode(node, isPattern ? \"ObjectPattern\" : \"ObjectExpression\")\n}\n\npp.parseProperty = function(isPattern, refDestructuringErrors) {\n  let prop = this.startNode(), isGenerator, isAsync, startPos, startLoc\n  if (this.options.ecmaVersion >= 9 && this.eat(tt.ellipsis)) {\n    if (isPattern) {\n      prop.argument = this.parseIdent(false)\n      if (this.type === tt.comma) {\n        this.raise(this.start, \"Comma is not permitted after the rest element\")\n      }\n      return this.finishNode(prop, \"RestElement\")\n    }\n    // To disallow parenthesized identifier via `this.toAssignable()`.\n    if (this.type === tt.parenL && refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0) {\n        refDestructuringErrors.parenthesizedAssign = this.start\n      }\n      if (refDestructuringErrors.parenthesizedBind < 0) {\n        refDestructuringErrors.parenthesizedBind = this.start\n      }\n    }\n    // Parse argument.\n    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors)\n    // To disallow trailing comma via `this.toAssignable()`.\n    if (this.type === tt.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {\n      refDestructuringErrors.trailingComma = this.start\n    }\n    // Finish\n    return this.finishNode(prop, \"SpreadElement\")\n  }\n  if (this.options.ecmaVersion >= 6) {\n    prop.method = false\n    prop.shorthand = false\n    if (isPattern || refDestructuringErrors) {\n      startPos = this.start\n      startLoc = this.startLoc\n    }\n    if (!isPattern)\n      isGenerator = this.eat(tt.star)\n  }\n  let containsEsc = this.containsEsc\n  this.parsePropertyName(prop)\n  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {\n    isAsync = true\n    isGenerator = this.options.ecmaVersion >= 9 && this.eat(tt.star)\n    this.parsePropertyName(prop, refDestructuringErrors)\n  } else {\n    isAsync = false\n  }\n  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc)\n  return this.finishNode(prop, \"Property\")\n}\n\npp.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {\n  if ((isGenerator || isAsync) && this.type === tt.colon)\n    this.unexpected()\n\n  if (this.eat(tt.colon)) {\n    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors)\n    prop.kind = \"init\"\n  } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {\n    if (isPattern) this.unexpected()\n    prop.kind = \"init\"\n    prop.method = true\n    prop.value = this.parseMethod(isGenerator, isAsync)\n  } else if (!isPattern && !containsEsc &&\n             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === \"Identifier\" &&\n             (prop.key.name === \"get\" || prop.key.name === \"set\") &&\n             (this.type !== tt.comma && this.type !== tt.braceR)) {\n    if (isGenerator || isAsync) this.unexpected()\n    prop.kind = prop.key.name\n    this.parsePropertyName(prop)\n    prop.value = this.parseMethod(false)\n    let paramCount = prop.kind === \"get\" ? 0 : 1\n    if (prop.value.params.length !== paramCount) {\n      let start = prop.value.start\n      if (prop.kind === \"get\")\n        this.raiseRecoverable(start, \"getter should have no params\")\n      else\n        this.raiseRecoverable(start, \"setter should have exactly one param\")\n    } else {\n      if (prop.kind === \"set\" && prop.value.params[0].type === \"RestElement\")\n        this.raiseRecoverable(prop.value.params[0].start, \"Setter cannot use rest params\")\n    }\n  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === \"Identifier\") {\n    if (isGenerator || isAsync) this.unexpected()\n    this.checkUnreserved(prop.key)\n    if (prop.key.name === \"await\" && !this.awaitIdentPos)\n      this.awaitIdentPos = startPos\n    prop.kind = \"init\"\n    if (isPattern) {\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)\n    } else if (this.type === tt.eq && refDestructuringErrors) {\n      if (refDestructuringErrors.shorthandAssign < 0)\n        refDestructuringErrors.shorthandAssign = this.start\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)\n    } else {\n      prop.value = prop.key\n    }\n    prop.shorthand = true\n  } else this.unexpected()\n}\n\npp.parsePropertyName = function(prop) {\n  if (this.options.ecmaVersion >= 6) {\n    if (this.eat(tt.bracketL)) {\n      prop.computed = true\n      prop.key = this.parseMaybeAssign()\n      this.expect(tt.bracketR)\n      return prop.key\n    } else {\n      prop.computed = false\n    }\n  }\n  return prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true)\n}\n\n// Initialize empty function node.\n\npp.initFunction = function(node) {\n  node.id = null\n  if (this.options.ecmaVersion >= 6) node.generator = node.expression = false\n  if (this.options.ecmaVersion >= 8) node.async = false\n}\n\n// Parse object or class method.\n\npp.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {\n  let node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n\n  this.initFunction(node)\n  if (this.options.ecmaVersion >= 6)\n    node.generator = isGenerator\n  if (this.options.ecmaVersion >= 8)\n    node.async = !!isAsync\n\n  this.yieldPos = 0\n  this.awaitPos = 0\n  this.awaitIdentPos = 0\n  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0))\n\n  this.expect(tt.parenL)\n  node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8)\n  this.checkYieldAwaitInDefaultParams()\n  this.parseFunctionBody(node, false, true)\n\n  this.yieldPos = oldYieldPos\n  this.awaitPos = oldAwaitPos\n  this.awaitIdentPos = oldAwaitIdentPos\n  return this.finishNode(node, \"FunctionExpression\")\n}\n\n// Parse arrow function expression with given parameters.\n\npp.parseArrowExpression = function(node, params, isAsync) {\n  let oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos\n\n  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW)\n  this.initFunction(node)\n  if (this.options.ecmaVersion >= 8) node.async = !!isAsync\n\n  this.yieldPos = 0\n  this.awaitPos = 0\n  this.awaitIdentPos = 0\n\n  node.params = this.toAssignableList(params, true)\n  this.parseFunctionBody(node, true, false)\n\n  this.yieldPos = oldYieldPos\n  this.awaitPos = oldAwaitPos\n  this.awaitIdentPos = oldAwaitIdentPos\n  return this.finishNode(node, \"ArrowFunctionExpression\")\n}\n\n// Parse function body and check parameters.\n\npp.parseFunctionBody = function(node, isArrowFunction, isMethod) {\n  let isExpression = isArrowFunction && this.type !== tt.braceL\n  let oldStrict = this.strict, useStrict = false\n\n  if (isExpression) {\n    node.body = this.parseMaybeAssign()\n    node.expression = true\n    this.checkParams(node, false)\n  } else {\n    let nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params)\n    if (!oldStrict || nonSimple) {\n      useStrict = this.strictDirective(this.end)\n      // If this is a strict mode function, verify that argument names\n      // are not repeated, and it does not try to bind the words `eval`\n      // or `arguments`.\n      if (useStrict && nonSimple)\n        this.raiseRecoverable(node.start, \"Illegal 'use strict' directive in function with non-simple parameter list\")\n    }\n    // Start a new scope with regard to labels and the `inFunction`\n    // flag (restore them to their old value afterwards).\n    let oldLabels = this.labels\n    this.labels = []\n    if (useStrict) this.strict = true\n\n    // Add the params to varDeclaredNames to ensure that an error is thrown\n    // if a let/const declaration in the function clashes with one of the params.\n    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params))\n    node.body = this.parseBlock(false)\n    node.expression = false\n    this.adaptDirectivePrologue(node.body.body)\n    this.labels = oldLabels\n  }\n  this.exitScope()\n\n  // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n  if (this.strict && node.id) this.checkLVal(node.id, BIND_OUTSIDE)\n  this.strict = oldStrict\n}\n\npp.isSimpleParamList = function(params) {\n  for (let param of params)\n    if (param.type !== \"Identifier\") return false\n  return true\n}\n\n// Checks function params for various disallowed patterns such as using \"eval\"\n// or \"arguments\" and duplicate parameters.\n\npp.checkParams = function(node, allowDuplicates) {\n  let nameHash = {}\n  for (let param of node.params)\n    this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash)\n}\n\n// Parses a comma-separated list of expressions, and returns them as\n// an array. `close` is the token type that ends the list, and\n// `allowEmpty` can be turned on to allow subsequent commas with\n// nothing in between them to be parsed as `null` (which is needed\n// for array literals).\n\npp.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {\n  let elts = [], first = true\n  while (!this.eat(close)) {\n    if (!first) {\n      this.expect(tt.comma)\n      if (allowTrailingComma && this.afterTrailingComma(close)) break\n    } else first = false\n\n    let elt\n    if (allowEmpty && this.type === tt.comma)\n      elt = null\n    else if (this.type === tt.ellipsis) {\n      elt = this.parseSpread(refDestructuringErrors)\n      if (refDestructuringErrors && this.type === tt.comma && refDestructuringErrors.trailingComma < 0)\n        refDestructuringErrors.trailingComma = this.start\n    } else {\n      elt = this.parseMaybeAssign(false, refDestructuringErrors)\n    }\n    elts.push(elt)\n  }\n  return elts\n}\n\npp.checkUnreserved = function({start, end, name}) {\n  if (this.inGenerator && name === \"yield\")\n    this.raiseRecoverable(start, \"Cannot use 'yield' as identifier inside a generator\")\n  if (this.inAsync && name === \"await\")\n    this.raiseRecoverable(start, \"Cannot use 'await' as identifier inside an async function\")\n  if (this.keywords.test(name))\n    this.raise(start, `Unexpected keyword '${name}'`)\n  if (this.options.ecmaVersion < 6 &&\n    this.input.slice(start, end).indexOf(\"\\\\\") !== -1) return\n  const re = this.strict ? this.reservedWordsStrict : this.reservedWords\n  if (re.test(name)) {\n    if (!this.inAsync && name === \"await\")\n      this.raiseRecoverable(start, \"Cannot use keyword 'await' outside an async function\")\n    this.raiseRecoverable(start, `The keyword '${name}' is reserved`)\n  }\n}\n\n// Parse the next token as an identifier. If `liberal` is true (used\n// when parsing properties), it will also convert keywords into\n// identifiers.\n\npp.parseIdent = function(liberal, isBinding) {\n  let node = this.startNode()\n  if (liberal && this.options.allowReserved === \"never\") liberal = false\n  if (this.type === tt.name) {\n    node.name = this.value\n  } else if (this.type.keyword) {\n    node.name = this.type.keyword\n\n    // To fix https://github.com/acornjs/acorn/issues/575\n    // `class` and `function` keywords push new context into this.context.\n    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.\n    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword\n    if ((node.name === \"class\" || node.name === \"function\") &&\n        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {\n      this.context.pop()\n    }\n  } else {\n    this.unexpected()\n  }\n  this.next()\n  this.finishNode(node, \"Identifier\")\n  if (!liberal) {\n    this.checkUnreserved(node)\n    if (node.name === \"await\" && !this.awaitIdentPos)\n      this.awaitIdentPos = node.start\n  }\n  return node\n}\n\n// Parses yield expression inside generator.\n\npp.parseYield = function(noIn) {\n  if (!this.yieldPos) this.yieldPos = this.start\n\n  let node = this.startNode()\n  this.next()\n  if (this.type === tt.semi || this.canInsertSemicolon() || (this.type !== tt.star && !this.type.startsExpr)) {\n    node.delegate = false\n    node.argument = null\n  } else {\n    node.delegate = this.eat(tt.star)\n    node.argument = this.parseMaybeAssign(noIn)\n  }\n  return this.finishNode(node, \"YieldExpression\")\n}\n\npp.parseAwait = function() {\n  if (!this.awaitPos) this.awaitPos = this.start\n\n  let node = this.startNode()\n  this.next()\n  node.argument = this.parseMaybeUnary(null, true)\n  return this.finishNode(node, \"AwaitExpression\")\n}\n","import {Parser} from \"./state\"\nimport {Position, getLineInfo} from \"./locutil\"\n\nconst pp = Parser.prototype\n\n// This function is used to raise exceptions on parse errors. It\n// takes an offset integer (into the current `input`) to indicate\n// the location of the error, attaches the position to the end\n// of the error message, and then raises a `SyntaxError` with that\n// message.\n\npp.raise = function(pos, message) {\n  let loc = getLineInfo(this.input, pos)\n  message += \" (\" + loc.line + \":\" + loc.column + \")\"\n  let err = new SyntaxError(message)\n  err.pos = pos; err.loc = loc; err.raisedAt = this.pos\n  throw err\n}\n\npp.raiseRecoverable = pp.raise\n\npp.curPosition = function() {\n  if (this.options.locations) {\n    return new Position(this.curLine, this.pos - this.lineStart)\n  }\n}\n","import {Parser} from \"./state\"\nimport {SCOPE_VAR, SCOPE_FUNCTION, SCOPE_TOP, SCOPE_ARROW, SCOPE_SIMPLE_CATCH, BIND_LEXICAL, BIND_SIMPLE_CATCH, BIND_FUNCTION} from \"./scopeflags\"\n\nconst pp = Parser.prototype\n\nclass Scope {\n  constructor(flags) {\n    this.flags = flags\n    // A list of var-declared names in the current lexical scope\n    this.var = []\n    // A list of lexically-declared names in the current lexical scope\n    this.lexical = []\n    // A list of lexically-declared FunctionDeclaration names in the current lexical scope\n    this.functions = []\n  }\n}\n\n// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.\n\npp.enterScope = function(flags) {\n  this.scopeStack.push(new Scope(flags))\n}\n\npp.exitScope = function() {\n  this.scopeStack.pop()\n}\n\n// The spec says:\n// > At the top level of a function, or script, function declarations are\n// > treated like var declarations rather than like lexical declarations.\npp.treatFunctionsAsVarInScope = function(scope) {\n  return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)\n}\n\npp.declareName = function(name, bindingType, pos) {\n  let redeclared = false\n  if (bindingType === BIND_LEXICAL) {\n    const scope = this.currentScope()\n    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1\n    scope.lexical.push(name)\n    if (this.inModule && (scope.flags & SCOPE_TOP))\n      delete this.undefinedExports[name]\n  } else if (bindingType === BIND_SIMPLE_CATCH) {\n    const scope = this.currentScope()\n    scope.lexical.push(name)\n  } else if (bindingType === BIND_FUNCTION) {\n    const scope = this.currentScope()\n    if (this.treatFunctionsAsVar)\n      redeclared = scope.lexical.indexOf(name) > -1\n    else\n      redeclared = scope.lexical.indexOf(name) > -1 || scope.var.indexOf(name) > -1\n    scope.functions.push(name)\n  } else {\n    for (let i = this.scopeStack.length - 1; i >= 0; --i) {\n      const scope = this.scopeStack[i]\n      if (scope.lexical.indexOf(name) > -1 && !((scope.flags & SCOPE_SIMPLE_CATCH) && scope.lexical[0] === name) ||\n          !this.treatFunctionsAsVarInScope(scope) && scope.functions.indexOf(name) > -1) {\n        redeclared = true\n        break\n      }\n      scope.var.push(name)\n      if (this.inModule && (scope.flags & SCOPE_TOP))\n        delete this.undefinedExports[name]\n      if (scope.flags & SCOPE_VAR) break\n    }\n  }\n  if (redeclared) this.raiseRecoverable(pos, `Identifier '${name}' has already been declared`)\n}\n\npp.checkLocalExport = function(id) {\n  // scope.functions must be empty as Module code is always strict.\n  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&\n      this.scopeStack[0].var.indexOf(id.name) === -1) {\n    this.undefinedExports[id.name] = id\n  }\n}\n\npp.currentScope = function() {\n  return this.scopeStack[this.scopeStack.length - 1]\n}\n\npp.currentVarScope = function() {\n  for (let i = this.scopeStack.length - 1;; i--) {\n    let scope = this.scopeStack[i]\n    if (scope.flags & SCOPE_VAR) return scope\n  }\n}\n\n// Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\npp.currentThisScope = function() {\n  for (let i = this.scopeStack.length - 1;; i--) {\n    let scope = this.scopeStack[i]\n    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) return scope\n  }\n}\n","import {Parser} from \"./state\"\nimport {SourceLocation} from \"./locutil\"\n\nexport class Node {\n  constructor(parser, pos, loc) {\n    this.type = \"\"\n    this.start = pos\n    this.end = 0\n    if (parser.options.locations)\n      this.loc = new SourceLocation(parser, loc)\n    if (parser.options.directSourceFile)\n      this.sourceFile = parser.options.directSourceFile\n    if (parser.options.ranges)\n      this.range = [pos, 0]\n  }\n}\n\n// Start an AST node, attaching a start offset.\n\nconst pp = Parser.prototype\n\npp.startNode = function() {\n  return new Node(this, this.start, this.startLoc)\n}\n\npp.startNodeAt = function(pos, loc) {\n  return new Node(this, pos, loc)\n}\n\n// Finish an AST node, adding `type` and `end` properties.\n\nfunction finishNodeAt(node, type, pos, loc) {\n  node.type = type\n  node.end = pos\n  if (this.options.locations)\n    node.loc.end = loc\n  if (this.options.ranges)\n    node.range[1] = pos\n  return node\n}\n\npp.finishNode = function(node, type) {\n  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)\n}\n\n// Finish node at given position\n\npp.finishNodeAt = function(node, type, pos, loc) {\n  return finishNodeAt.call(this, node, type, pos, loc)\n}\n","// The algorithm used to determine whether a regexp can appear at a\n// given point in the program is loosely based on sweet.js' approach.\n// See https://github.com/mozilla/sweet.js/wiki/design\n\nimport {Parser} from \"./state\"\nimport {types as tt} from \"./tokentype\"\nimport {lineBreak} from \"./whitespace\"\n\nexport class TokContext {\n  constructor(token, isExpr, preserveSpace, override, generator) {\n    this.token = token\n    this.isExpr = !!isExpr\n    this.preserveSpace = !!preserveSpace\n    this.override = override\n    this.generator = !!generator\n  }\n}\n\nexport const types = {\n  b_stat: new TokContext(\"{\", false),\n  b_expr: new TokContext(\"{\", true),\n  b_tmpl: new TokContext(\"${\", false),\n  p_stat: new TokContext(\"(\", false),\n  p_expr: new TokContext(\"(\", true),\n  q_tmpl: new TokContext(\"`\", true, true, p => p.tryReadTemplateToken()),\n  f_stat: new TokContext(\"function\", false),\n  f_expr: new TokContext(\"function\", true),\n  f_expr_gen: new TokContext(\"function\", true, false, null, true),\n  f_gen: new TokContext(\"function\", false, false, null, true)\n}\n\nconst pp = Parser.prototype\n\npp.initialContext = function() {\n  return [types.b_stat]\n}\n\npp.braceIsBlock = function(prevType) {\n  let parent = this.curContext()\n  if (parent === types.f_expr || parent === types.f_stat)\n    return true\n  if (prevType === tt.colon && (parent === types.b_stat || parent === types.b_expr))\n    return !parent.isExpr\n\n  // The check for `tt.name && exprAllowed` detects whether we are\n  // after a `yield` or `of` construct. See the `updateContext` for\n  // `tt.name`.\n  if (prevType === tt._return || prevType === tt.name && this.exprAllowed)\n    return lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n  if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof || prevType === tt.parenR || prevType === tt.arrow)\n    return true\n  if (prevType === tt.braceL)\n    return parent === types.b_stat\n  if (prevType === tt._var || prevType === tt._const || prevType === tt.name)\n    return false\n  return !this.exprAllowed\n}\n\npp.inGeneratorContext = function() {\n  for (let i = this.context.length - 1; i >= 1; i--) {\n    let context = this.context[i]\n    if (context.token === \"function\")\n      return context.generator\n  }\n  return false\n}\n\npp.updateContext = function(prevType) {\n  let update, type = this.type\n  if (type.keyword && prevType === tt.dot)\n    this.exprAllowed = false\n  else if (update = type.updateContext)\n    update.call(this, prevType)\n  else\n    this.exprAllowed = type.beforeExpr\n}\n\n// Token-specific context update code\n\ntt.parenR.updateContext = tt.braceR.updateContext = function() {\n  if (this.context.length === 1) {\n    this.exprAllowed = true\n    return\n  }\n  let out = this.context.pop()\n  if (out === types.b_stat && this.curContext().token === \"function\") {\n    out = this.context.pop()\n  }\n  this.exprAllowed = !out.isExpr\n}\n\ntt.braceL.updateContext = function(prevType) {\n  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr)\n  this.exprAllowed = true\n}\n\ntt.dollarBraceL.updateContext = function() {\n  this.context.push(types.b_tmpl)\n  this.exprAllowed = true\n}\n\ntt.parenL.updateContext = function(prevType) {\n  let statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while\n  this.context.push(statementParens ? types.p_stat : types.p_expr)\n  this.exprAllowed = true\n}\n\ntt.incDec.updateContext = function() {\n  // tokExprAllowed stays unchanged\n}\n\ntt._function.updateContext = tt._class.updateContext = function(prevType) {\n  if (prevType.beforeExpr && prevType !== tt.semi && prevType !== tt._else &&\n      !(prevType === tt._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&\n      !((prevType === tt.colon || prevType === tt.braceL) && this.curContext() === types.b_stat))\n    this.context.push(types.f_expr)\n  else\n    this.context.push(types.f_stat)\n  this.exprAllowed = false\n}\n\ntt.backQuote.updateContext = function() {\n  if (this.curContext() === types.q_tmpl)\n    this.context.pop()\n  else\n    this.context.push(types.q_tmpl)\n  this.exprAllowed = false\n}\n\ntt.star.updateContext = function(prevType) {\n  if (prevType === tt._function) {\n    let index = this.context.length - 1\n    if (this.context[index] === types.f_expr)\n      this.context[index] = types.f_expr_gen\n    else\n      this.context[index] = types.f_gen\n  }\n  this.exprAllowed = true\n}\n\ntt.name.updateContext = function(prevType) {\n  let allowed = false\n  if (this.options.ecmaVersion >= 6 && prevType !== tt.dot) {\n    if (this.value === \"of\" && !this.exprAllowed ||\n        this.value === \"yield\" && this.inGeneratorContext())\n      allowed = true\n  }\n  this.exprAllowed = allowed\n}\n","import {wordsRegexp} from \"./util.js\"\n\n// This file contains Unicode properties extracted from the ECMAScript\n// specification. The lists are extracted like so:\n// $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)\n\n// #table-binary-unicode-properties\nconst ecma9BinaryProperties = \"ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS\"\nconst unicodeBinaryProperties = {\n  9: ecma9BinaryProperties,\n  10: ecma9BinaryProperties + \" Extended_Pictographic\"\n}\n\n// #table-unicode-general-category-values\nconst unicodeGeneralCategoryValues = \"Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu\"\n\n// #table-unicode-script-values\nconst ecma9ScriptValues = \"Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb\"\nconst unicodeScriptValues = {\n  9: ecma9ScriptValues,\n  10: ecma9ScriptValues + \" Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd\"\n}\n\nconst data = {}\nfunction buildUnicodeData(ecmaVersion) {\n  let d = data[ecmaVersion] = {\n    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + \" \" + unicodeGeneralCategoryValues),\n    nonBinary: {\n      General_Category: wordsRegexp(unicodeGeneralCategoryValues),\n      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])\n    }\n  }\n  d.nonBinary.Script_Extensions = d.nonBinary.Script\n\n  d.nonBinary.gc = d.nonBinary.General_Category\n  d.nonBinary.sc = d.nonBinary.Script\n  d.nonBinary.scx = d.nonBinary.Script_Extensions\n}\nbuildUnicodeData(9)\nbuildUnicodeData(10)\n\nexport default data\n","import {isIdentifierStart, isIdentifierChar} from \"./identifier.js\"\nimport {Parser} from \"./state.js\"\nimport UNICODE_PROPERTY_VALUES from \"./unicode-property-data.js\"\nimport {has} from \"./util.js\"\n\nconst pp = Parser.prototype\n\nexport class RegExpValidationState {\n  constructor(parser) {\n    this.parser = parser\n    this.validFlags = `gim${parser.options.ecmaVersion >= 6 ? \"uy\" : \"\"}${parser.options.ecmaVersion >= 9 ? \"s\" : \"\"}`\n    this.unicodeProperties = UNICODE_PROPERTY_VALUES[parser.options.ecmaVersion >= 10 ? 10 : parser.options.ecmaVersion]\n    this.source = \"\"\n    this.flags = \"\"\n    this.start = 0\n    this.switchU = false\n    this.switchN = false\n    this.pos = 0\n    this.lastIntValue = 0\n    this.lastStringValue = \"\"\n    this.lastAssertionIsQuantifiable = false\n    this.numCapturingParens = 0\n    this.maxBackReference = 0\n    this.groupNames = []\n    this.backReferenceNames = []\n  }\n\n  reset(start, pattern, flags) {\n    const unicode = flags.indexOf(\"u\") !== -1\n    this.start = start | 0\n    this.source = pattern + \"\"\n    this.flags = flags\n    this.switchU = unicode && this.parser.options.ecmaVersion >= 6\n    this.switchN = unicode && this.parser.options.ecmaVersion >= 9\n  }\n\n  raise(message) {\n    this.parser.raiseRecoverable(this.start, `Invalid regular expression: /${this.source}/: ${message}`)\n  }\n\n  // If u flag is given, this returns the code point at the index (it combines a surrogate pair).\n  // Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).\n  at(i) {\n    const s = this.source\n    const l = s.length\n    if (i >= l) {\n      return -1\n    }\n    const c = s.charCodeAt(i)\n    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n      return c\n    }\n    return (c << 10) + s.charCodeAt(i + 1) - 0x35FDC00\n  }\n\n  nextIndex(i) {\n    const s = this.source\n    const l = s.length\n    if (i >= l) {\n      return l\n    }\n    const c = s.charCodeAt(i)\n    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n      return i + 1\n    }\n    return i + 2\n  }\n\n  current() {\n    return this.at(this.pos)\n  }\n\n  lookahead() {\n    return this.at(this.nextIndex(this.pos))\n  }\n\n  advance() {\n    this.pos = this.nextIndex(this.pos)\n  }\n\n  eat(ch) {\n    if (this.current() === ch) {\n      this.advance()\n      return true\n    }\n    return false\n  }\n}\n\nfunction codePointToString(ch) {\n  if (ch <= 0xFFFF) return String.fromCharCode(ch)\n  ch -= 0x10000\n  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)\n}\n\n/**\n * Validate the flags part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp.validateRegExpFlags = function(state) {\n  const validFlags = state.validFlags\n  const flags = state.flags\n\n  for (let i = 0; i < flags.length; i++) {\n    const flag = flags.charAt(i)\n    if (validFlags.indexOf(flag) === -1) {\n      this.raise(state.start, \"Invalid regular expression flag\")\n    }\n    if (flags.indexOf(flag, i + 1) > -1) {\n      this.raise(state.start, \"Duplicate regular expression flag\")\n    }\n  }\n}\n\n/**\n * Validate the pattern part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp.validateRegExpPattern = function(state) {\n  this.regexp_pattern(state)\n\n  // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of\n  // parsing contains a |GroupName|, reparse with the goal symbol\n  // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*\n  // exception if _P_ did not conform to the grammar, if any elements of _P_\n  // were not matched by the parse, or if any Early Error conditions exist.\n  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {\n    state.switchN = true\n    this.regexp_pattern(state)\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern\npp.regexp_pattern = function(state) {\n  state.pos = 0\n  state.lastIntValue = 0\n  state.lastStringValue = \"\"\n  state.lastAssertionIsQuantifiable = false\n  state.numCapturingParens = 0\n  state.maxBackReference = 0\n  state.groupNames.length = 0\n  state.backReferenceNames.length = 0\n\n  this.regexp_disjunction(state)\n\n  if (state.pos !== state.source.length) {\n    // Make the same messages as V8.\n    if (state.eat(0x29 /* ) */)) {\n      state.raise(\"Unmatched ')'\")\n    }\n    if (state.eat(0x5D /* [ */) || state.eat(0x7D /* } */)) {\n      state.raise(\"Lone quantifier brackets\")\n    }\n  }\n  if (state.maxBackReference > state.numCapturingParens) {\n    state.raise(\"Invalid escape\")\n  }\n  for (const name of state.backReferenceNames) {\n    if (state.groupNames.indexOf(name) === -1) {\n      state.raise(\"Invalid named capture referenced\")\n    }\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction\npp.regexp_disjunction = function(state) {\n  this.regexp_alternative(state)\n  while (state.eat(0x7C /* | */)) {\n    this.regexp_alternative(state)\n  }\n\n  // Make the same message as V8.\n  if (this.regexp_eatQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\")\n  }\n  if (state.eat(0x7B /* { */)) {\n    state.raise(\"Lone quantifier brackets\")\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative\npp.regexp_alternative = function(state) {\n  while (state.pos < state.source.length && this.regexp_eatTerm(state))\n    ;\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term\npp.regexp_eatTerm = function(state) {\n  if (this.regexp_eatAssertion(state)) {\n    // Handle `QuantifiableAssertion Quantifier` alternative.\n    // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion\n    // is a QuantifiableAssertion.\n    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {\n      // Make the same message as V8.\n      if (state.switchU) {\n        state.raise(\"Invalid quantifier\")\n      }\n    }\n    return true\n  }\n\n  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {\n    this.regexp_eatQuantifier(state)\n    return true\n  }\n\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion\npp.regexp_eatAssertion = function(state) {\n  const start = state.pos\n  state.lastAssertionIsQuantifiable = false\n\n  // ^, $\n  if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {\n    return true\n  }\n\n  // \\b \\B\n  if (state.eat(0x5C /* \\ */)) {\n    if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {\n      return true\n    }\n    state.pos = start\n  }\n\n  // Lookahead / Lookbehind\n  if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {\n    let lookbehind = false\n    if (this.options.ecmaVersion >= 9) {\n      lookbehind = state.eat(0x3C /* < */)\n    }\n    if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {\n      this.regexp_disjunction(state)\n      if (!state.eat(0x29 /* ) */)) {\n        state.raise(\"Unterminated group\")\n      }\n      state.lastAssertionIsQuantifiable = !lookbehind\n      return true\n    }\n  }\n\n  state.pos = start\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier\npp.regexp_eatQuantifier = function(state, noError = false) {\n  if (this.regexp_eatQuantifierPrefix(state, noError)) {\n    state.eat(0x3F /* ? */)\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix\npp.regexp_eatQuantifierPrefix = function(state, noError) {\n  return (\n    state.eat(0x2A /* * */) ||\n    state.eat(0x2B /* + */) ||\n    state.eat(0x3F /* ? */) ||\n    this.regexp_eatBracedQuantifier(state, noError)\n  )\n}\npp.regexp_eatBracedQuantifier = function(state, noError) {\n  const start = state.pos\n  if (state.eat(0x7B /* { */)) {\n    let min = 0, max = -1\n    if (this.regexp_eatDecimalDigits(state)) {\n      min = state.lastIntValue\n      if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {\n        max = state.lastIntValue\n      }\n      if (state.eat(0x7D /* } */)) {\n        // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term\n        if (max !== -1 && max < min && !noError) {\n          state.raise(\"numbers out of order in {} quantifier\")\n        }\n        return true\n      }\n    }\n    if (state.switchU && !noError) {\n      state.raise(\"Incomplete quantifier\")\n    }\n    state.pos = start\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom\npp.regexp_eatAtom = function(state) {\n  return (\n    this.regexp_eatPatternCharacters(state) ||\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state)\n  )\n}\npp.regexp_eatReverseSolidusAtomEscape = function(state) {\n  const start = state.pos\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatAtomEscape(state)) {\n      return true\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatUncapturingGroup = function(state) {\n  const start = state.pos\n  if (state.eat(0x28 /* ( */)) {\n    if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {\n      this.regexp_disjunction(state)\n      if (state.eat(0x29 /* ) */)) {\n        return true\n      }\n      state.raise(\"Unterminated group\")\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatCapturingGroup = function(state) {\n  if (state.eat(0x28 /* ( */)) {\n    if (this.options.ecmaVersion >= 9) {\n      this.regexp_groupSpecifier(state)\n    } else if (state.current() === 0x3F /* ? */) {\n      state.raise(\"Invalid group\")\n    }\n    this.regexp_disjunction(state)\n    if (state.eat(0x29 /* ) */)) {\n      state.numCapturingParens += 1\n      return true\n    }\n    state.raise(\"Unterminated group\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom\npp.regexp_eatExtendedAtom = function(state) {\n  return (\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state) ||\n    this.regexp_eatInvalidBracedQuantifier(state) ||\n    this.regexp_eatExtendedPatternCharacter(state)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier\npp.regexp_eatInvalidBracedQuantifier = function(state) {\n  if (this.regexp_eatBracedQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter\npp.regexp_eatSyntaxCharacter = function(state) {\n  const ch = state.current()\n  if (isSyntaxCharacter(ch)) {\n    state.lastIntValue = ch\n    state.advance()\n    return true\n  }\n  return false\n}\nfunction isSyntaxCharacter(ch) {\n  return (\n    ch === 0x24 /* $ */ ||\n    ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||\n    ch === 0x2E /* . */ ||\n    ch === 0x3F /* ? */ ||\n    ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||\n    ch >= 0x7B /* { */ && ch <= 0x7D /* } */\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter\n// But eat eager.\npp.regexp_eatPatternCharacters = function(state) {\n  const start = state.pos\n  let ch = 0\n  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {\n    state.advance()\n  }\n  return state.pos !== start\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter\npp.regexp_eatExtendedPatternCharacter = function(state) {\n  const ch = state.current()\n  if (\n    ch !== -1 &&\n    ch !== 0x24 /* $ */ &&\n    !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&\n    ch !== 0x2E /* . */ &&\n    ch !== 0x3F /* ? */ &&\n    ch !== 0x5B /* [ */ &&\n    ch !== 0x5E /* ^ */ &&\n    ch !== 0x7C /* | */\n  ) {\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// GroupSpecifier[U] ::\n//   [empty]\n//   `?` GroupName[?U]\npp.regexp_groupSpecifier = function(state) {\n  if (state.eat(0x3F /* ? */)) {\n    if (this.regexp_eatGroupName(state)) {\n      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {\n        state.raise(\"Duplicate capture group name\")\n      }\n      state.groupNames.push(state.lastStringValue)\n      return\n    }\n    state.raise(\"Invalid group\")\n  }\n}\n\n// GroupName[U] ::\n//   `<` RegExpIdentifierName[?U] `>`\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp.regexp_eatGroupName = function(state) {\n  state.lastStringValue = \"\"\n  if (state.eat(0x3C /* < */)) {\n    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {\n      return true\n    }\n    state.raise(\"Invalid capture group name\")\n  }\n  return false\n}\n\n// RegExpIdentifierName[U] ::\n//   RegExpIdentifierStart[?U]\n//   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp.regexp_eatRegExpIdentifierName = function(state) {\n  state.lastStringValue = \"\"\n  if (this.regexp_eatRegExpIdentifierStart(state)) {\n    state.lastStringValue += codePointToString(state.lastIntValue)\n    while (this.regexp_eatRegExpIdentifierPart(state)) {\n      state.lastStringValue += codePointToString(state.lastIntValue)\n    }\n    return true\n  }\n  return false\n}\n\n// RegExpIdentifierStart[U] ::\n//   UnicodeIDStart\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[?U]\npp.regexp_eatRegExpIdentifierStart = function(state) {\n  const start = state.pos\n  let ch = state.current()\n  state.advance()\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {\n    ch = state.lastIntValue\n  }\n  if (isRegExpIdentifierStart(ch)) {\n    state.lastIntValue = ch\n    return true\n  }\n\n  state.pos = start\n  return false\n}\nfunction isRegExpIdentifierStart(ch) {\n  return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */\n}\n\n// RegExpIdentifierPart[U] ::\n//   UnicodeIDContinue\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[?U]\n//   <ZWNJ>\n//   <ZWJ>\npp.regexp_eatRegExpIdentifierPart = function(state) {\n  const start = state.pos\n  let ch = state.current()\n  state.advance()\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {\n    ch = state.lastIntValue\n  }\n  if (isRegExpIdentifierPart(ch)) {\n    state.lastIntValue = ch\n    return true\n  }\n\n  state.pos = start\n  return false\n}\nfunction isRegExpIdentifierPart(ch) {\n  return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape\npp.regexp_eatAtomEscape = function(state) {\n  if (\n    this.regexp_eatBackReference(state) ||\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state) ||\n    (state.switchN && this.regexp_eatKGroupName(state))\n  ) {\n    return true\n  }\n  if (state.switchU) {\n    // Make the same message as V8.\n    if (state.current() === 0x63 /* c */) {\n      state.raise(\"Invalid unicode escape\")\n    }\n    state.raise(\"Invalid escape\")\n  }\n  return false\n}\npp.regexp_eatBackReference = function(state) {\n  const start = state.pos\n  if (this.regexp_eatDecimalEscape(state)) {\n    const n = state.lastIntValue\n    if (state.switchU) {\n      // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape\n      if (n > state.maxBackReference) {\n        state.maxBackReference = n\n      }\n      return true\n    }\n    if (n <= state.numCapturingParens) {\n      return true\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatKGroupName = function(state) {\n  if (state.eat(0x6B /* k */)) {\n    if (this.regexp_eatGroupName(state)) {\n      state.backReferenceNames.push(state.lastStringValue)\n      return true\n    }\n    state.raise(\"Invalid named reference\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape\npp.regexp_eatCharacterEscape = function(state) {\n  return (\n    this.regexp_eatControlEscape(state) ||\n    this.regexp_eatCControlLetter(state) ||\n    this.regexp_eatZero(state) ||\n    this.regexp_eatHexEscapeSequence(state) ||\n    this.regexp_eatRegExpUnicodeEscapeSequence(state) ||\n    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||\n    this.regexp_eatIdentityEscape(state)\n  )\n}\npp.regexp_eatCControlLetter = function(state) {\n  const start = state.pos\n  if (state.eat(0x63 /* c */)) {\n    if (this.regexp_eatControlLetter(state)) {\n      return true\n    }\n    state.pos = start\n  }\n  return false\n}\npp.regexp_eatZero = function(state) {\n  if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {\n    state.lastIntValue = 0\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape\npp.regexp_eatControlEscape = function(state) {\n  const ch = state.current()\n  if (ch === 0x74 /* t */) {\n    state.lastIntValue = 0x09 /* \\t */\n    state.advance()\n    return true\n  }\n  if (ch === 0x6E /* n */) {\n    state.lastIntValue = 0x0A /* \\n */\n    state.advance()\n    return true\n  }\n  if (ch === 0x76 /* v */) {\n    state.lastIntValue = 0x0B /* \\v */\n    state.advance()\n    return true\n  }\n  if (ch === 0x66 /* f */) {\n    state.lastIntValue = 0x0C /* \\f */\n    state.advance()\n    return true\n  }\n  if (ch === 0x72 /* r */) {\n    state.lastIntValue = 0x0D /* \\r */\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter\npp.regexp_eatControlLetter = function(state) {\n  const ch = state.current()\n  if (isControlLetter(ch)) {\n    state.lastIntValue = ch % 0x20\n    state.advance()\n    return true\n  }\n  return false\n}\nfunction isControlLetter(ch) {\n  return (\n    (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence\npp.regexp_eatRegExpUnicodeEscapeSequence = function(state) {\n  const start = state.pos\n\n  if (state.eat(0x75 /* u */)) {\n    if (this.regexp_eatFixedHexDigits(state, 4)) {\n      const lead = state.lastIntValue\n      if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {\n        const leadSurrogateEnd = state.pos\n        if (state.eat(0x5C /* \\ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {\n          const trail = state.lastIntValue\n          if (trail >= 0xDC00 && trail <= 0xDFFF) {\n            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000\n            return true\n          }\n        }\n        state.pos = leadSurrogateEnd\n        state.lastIntValue = lead\n      }\n      return true\n    }\n    if (\n      state.switchU &&\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatHexDigits(state) &&\n      state.eat(0x7D /* } */) &&\n      isValidUnicode(state.lastIntValue)\n    ) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid unicode escape\")\n    }\n    state.pos = start\n  }\n\n  return false\n}\nfunction isValidUnicode(ch) {\n  return ch >= 0 && ch <= 0x10FFFF\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape\npp.regexp_eatIdentityEscape = function(state) {\n  if (state.switchU) {\n    if (this.regexp_eatSyntaxCharacter(state)) {\n      return true\n    }\n    if (state.eat(0x2F /* / */)) {\n      state.lastIntValue = 0x2F /* / */\n      return true\n    }\n    return false\n  }\n\n  const ch = state.current()\n  if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {\n    state.lastIntValue = ch\n    state.advance()\n    return true\n  }\n\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape\npp.regexp_eatDecimalEscape = function(state) {\n  state.lastIntValue = 0\n  let ch = state.current()\n  if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {\n    do {\n      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */)\n      state.advance()\n    } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape\npp.regexp_eatCharacterClassEscape = function(state) {\n  const ch = state.current()\n\n  if (isCharacterClassEscape(ch)) {\n    state.lastIntValue = -1\n    state.advance()\n    return true\n  }\n\n  if (\n    state.switchU &&\n    this.options.ecmaVersion >= 9 &&\n    (ch === 0x50 /* P */ || ch === 0x70 /* p */)\n  ) {\n    state.lastIntValue = -1\n    state.advance()\n    if (\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatUnicodePropertyValueExpression(state) &&\n      state.eat(0x7D /* } */)\n    ) {\n      return true\n    }\n    state.raise(\"Invalid property name\")\n  }\n\n  return false\n}\nfunction isCharacterClassEscape(ch) {\n  return (\n    ch === 0x64 /* d */ ||\n    ch === 0x44 /* D */ ||\n    ch === 0x73 /* s */ ||\n    ch === 0x53 /* S */ ||\n    ch === 0x77 /* w */ ||\n    ch === 0x57 /* W */\n  )\n}\n\n// UnicodePropertyValueExpression ::\n//   UnicodePropertyName `=` UnicodePropertyValue\n//   LoneUnicodePropertyNameOrValue\npp.regexp_eatUnicodePropertyValueExpression = function(state) {\n  const start = state.pos\n\n  // UnicodePropertyName `=` UnicodePropertyValue\n  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {\n    const name = state.lastStringValue\n    if (this.regexp_eatUnicodePropertyValue(state)) {\n      const value = state.lastStringValue\n      this.regexp_validateUnicodePropertyNameAndValue(state, name, value)\n      return true\n    }\n  }\n  state.pos = start\n\n  // LoneUnicodePropertyNameOrValue\n  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {\n    const nameOrValue = state.lastStringValue\n    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue)\n    return true\n  }\n  return false\n}\npp.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {\n  if (!has(state.unicodeProperties.nonBinary, name))\n    state.raise(\"Invalid property name\")\n  if (!state.unicodeProperties.nonBinary[name].test(value))\n    state.raise(\"Invalid property value\")\n}\npp.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {\n  if (!state.unicodeProperties.binary.test(nameOrValue))\n    state.raise(\"Invalid property name\")\n}\n\n// UnicodePropertyName ::\n//   UnicodePropertyNameCharacters\npp.regexp_eatUnicodePropertyName = function(state) {\n  let ch = 0\n  state.lastStringValue = \"\"\n  while (isUnicodePropertyNameCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch)\n    state.advance()\n  }\n  return state.lastStringValue !== \"\"\n}\nfunction isUnicodePropertyNameCharacter(ch) {\n  return isControlLetter(ch) || ch === 0x5F /* _ */\n}\n\n// UnicodePropertyValue ::\n//   UnicodePropertyValueCharacters\npp.regexp_eatUnicodePropertyValue = function(state) {\n  let ch = 0\n  state.lastStringValue = \"\"\n  while (isUnicodePropertyValueCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch)\n    state.advance()\n  }\n  return state.lastStringValue !== \"\"\n}\nfunction isUnicodePropertyValueCharacter(ch) {\n  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)\n}\n\n// LoneUnicodePropertyNameOrValue ::\n//   UnicodePropertyValueCharacters\npp.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {\n  return this.regexp_eatUnicodePropertyValue(state)\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass\npp.regexp_eatCharacterClass = function(state) {\n  if (state.eat(0x5B /* [ */)) {\n    state.eat(0x5E /* ^ */)\n    this.regexp_classRanges(state)\n    if (state.eat(0x5D /* [ */)) {\n      return true\n    }\n    // Unreachable since it threw \"unterminated regular expression\" error before.\n    state.raise(\"Unterminated character class\")\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash\npp.regexp_classRanges = function(state) {\n  while (this.regexp_eatClassAtom(state)) {\n    const left = state.lastIntValue\n    if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {\n      const right = state.lastIntValue\n      if (state.switchU && (left === -1 || right === -1)) {\n        state.raise(\"Invalid character class\")\n      }\n      if (left !== -1 && right !== -1 && left > right) {\n        state.raise(\"Range out of order in character class\")\n      }\n    }\n  }\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash\npp.regexp_eatClassAtom = function(state) {\n  const start = state.pos\n\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatClassEscape(state)) {\n      return true\n    }\n    if (state.switchU) {\n      // Make the same message as V8.\n      const ch = state.current()\n      if (ch === 0x63 /* c */ || isOctalDigit(ch)) {\n        state.raise(\"Invalid class escape\")\n      }\n      state.raise(\"Invalid escape\")\n    }\n    state.pos = start\n  }\n\n  const ch = state.current()\n  if (ch !== 0x5D /* [ */) {\n    state.lastIntValue = ch\n    state.advance()\n    return true\n  }\n\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape\npp.regexp_eatClassEscape = function(state) {\n  const start = state.pos\n\n  if (state.eat(0x62 /* b */)) {\n    state.lastIntValue = 0x08 /* <BS> */\n    return true\n  }\n\n  if (state.switchU && state.eat(0x2D /* - */)) {\n    state.lastIntValue = 0x2D /* - */\n    return true\n  }\n\n  if (!state.switchU && state.eat(0x63 /* c */)) {\n    if (this.regexp_eatClassControlLetter(state)) {\n      return true\n    }\n    state.pos = start\n  }\n\n  return (\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter\npp.regexp_eatClassControlLetter = function(state) {\n  const ch = state.current()\n  if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {\n    state.lastIntValue = ch % 0x20\n    state.advance()\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp.regexp_eatHexEscapeSequence = function(state) {\n  const start = state.pos\n  if (state.eat(0x78 /* x */)) {\n    if (this.regexp_eatFixedHexDigits(state, 2)) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid escape\")\n    }\n    state.pos = start\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits\npp.regexp_eatDecimalDigits = function(state) {\n  const start = state.pos\n  let ch = 0\n  state.lastIntValue = 0\n  while (isDecimalDigit(ch = state.current())) {\n    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */)\n    state.advance()\n  }\n  return state.pos !== start\n}\nfunction isDecimalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits\npp.regexp_eatHexDigits = function(state) {\n  const start = state.pos\n  let ch = 0\n  state.lastIntValue = 0\n  while (isHexDigit(ch = state.current())) {\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch)\n    state.advance()\n  }\n  return state.pos !== start\n}\nfunction isHexDigit(ch) {\n  return (\n    (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||\n    (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)\n  )\n}\nfunction hexToInt(ch) {\n  if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {\n    return 10 + (ch - 0x41 /* A */)\n  }\n  if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {\n    return 10 + (ch - 0x61 /* a */)\n  }\n  return ch - 0x30 /* 0 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence\n// Allows only 0-377(octal) i.e. 0-255(decimal).\npp.regexp_eatLegacyOctalEscapeSequence = function(state) {\n  if (this.regexp_eatOctalDigit(state)) {\n    const n1 = state.lastIntValue\n    if (this.regexp_eatOctalDigit(state)) {\n      const n2 = state.lastIntValue\n      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {\n        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue\n      } else {\n        state.lastIntValue = n1 * 8 + n2\n      }\n    } else {\n      state.lastIntValue = n1\n    }\n    return true\n  }\n  return false\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit\npp.regexp_eatOctalDigit = function(state) {\n  const ch = state.current()\n  if (isOctalDigit(ch)) {\n    state.lastIntValue = ch - 0x30 /* 0 */\n    state.advance()\n    return true\n  }\n  state.lastIntValue = 0\n  return false\n}\nfunction isOctalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit\n// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp.regexp_eatFixedHexDigits = function(state, length) {\n  const start = state.pos\n  state.lastIntValue = 0\n  for (let i = 0; i < length; ++i) {\n    const ch = state.current()\n    if (!isHexDigit(ch)) {\n      state.pos = start\n      return false\n    }\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch)\n    state.advance()\n  }\n  return true\n}\n","import {isIdentifierStart, isIdentifierChar} from \"./identifier\"\nimport {types as tt, keywords as keywordTypes} from \"./tokentype\"\nimport {Parser} from \"./state\"\nimport {SourceLocation} from \"./locutil\"\nimport {RegExpValidationState} from \"./regexp\"\nimport {lineBreak, lineBreakG, isNewLine, nonASCIIwhitespace} from \"./whitespace\"\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nexport class Token {\n  constructor(p) {\n    this.type = p.type\n    this.value = p.value\n    this.start = p.start\n    this.end = p.end\n    if (p.options.locations)\n      this.loc = new SourceLocation(p, p.startLoc, p.endLoc)\n    if (p.options.ranges)\n      this.range = [p.start, p.end]\n  }\n}\n\n// ## Tokenizer\n\nconst pp = Parser.prototype\n\n// Move to the next token\n\npp.next = function() {\n  if (this.options.onToken)\n    this.options.onToken(new Token(this))\n\n  this.lastTokEnd = this.end\n  this.lastTokStart = this.start\n  this.lastTokEndLoc = this.endLoc\n  this.lastTokStartLoc = this.startLoc\n  this.nextToken()\n}\n\npp.getToken = function() {\n  this.next()\n  return new Token(this)\n}\n\n// If we're in an ES6 environment, make parsers iterable\nif (typeof Symbol !== \"undefined\")\n  pp[Symbol.iterator] = function() {\n    return {\n      next: () => {\n        let token = this.getToken()\n        return {\n          done: token.type === tt.eof,\n          value: token\n        }\n      }\n    }\n  }\n\n// Toggle strict mode. Re-reads the next number or string to please\n// pedantic tests (`\"use strict\"; 010;` should fail).\n\npp.curContext = function() {\n  return this.context[this.context.length - 1]\n}\n\n// Read a single token, updating the parser object's token-related\n// properties.\n\npp.nextToken = function() {\n  let curContext = this.curContext()\n  if (!curContext || !curContext.preserveSpace) this.skipSpace()\n\n  this.start = this.pos\n  if (this.options.locations) this.startLoc = this.curPosition()\n  if (this.pos >= this.input.length) return this.finishToken(tt.eof)\n\n  if (curContext.override) return curContext.override(this)\n  else this.readToken(this.fullCharCodeAtPos())\n}\n\npp.readToken = function(code) {\n  // Identifier or keyword. '\\uXXXX' sequences are allowed in\n  // identifiers, so '\\' also dispatches to that.\n  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\\' */)\n    return this.readWord()\n\n  return this.getTokenFromCode(code)\n}\n\npp.fullCharCodeAtPos = function() {\n  let code = this.input.charCodeAt(this.pos)\n  if (code <= 0xd7ff || code >= 0xe000) return code\n  let next = this.input.charCodeAt(this.pos + 1)\n  return (code << 10) + next - 0x35fdc00\n}\n\npp.skipBlockComment = function() {\n  let startLoc = this.options.onComment && this.curPosition()\n  let start = this.pos, end = this.input.indexOf(\"*/\", this.pos += 2)\n  if (end === -1) this.raise(this.pos - 2, \"Unterminated comment\")\n  this.pos = end + 2\n  if (this.options.locations) {\n    lineBreakG.lastIndex = start\n    let match\n    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {\n      ++this.curLine\n      this.lineStart = match.index + match[0].length\n    }\n  }\n  if (this.options.onComment)\n    this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,\n                           startLoc, this.curPosition())\n}\n\npp.skipLineComment = function(startSkip) {\n  let start = this.pos\n  let startLoc = this.options.onComment && this.curPosition()\n  let ch = this.input.charCodeAt(this.pos += startSkip)\n  while (this.pos < this.input.length && !isNewLine(ch)) {\n    ch = this.input.charCodeAt(++this.pos)\n  }\n  if (this.options.onComment)\n    this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,\n                           startLoc, this.curPosition())\n}\n\n// Called at the start of the parse and after every token. Skips\n// whitespace and comments, and.\n\npp.skipSpace = function() {\n  loop: while (this.pos < this.input.length) {\n    let ch = this.input.charCodeAt(this.pos)\n    switch (ch) {\n    case 32: case 160: // ' '\n      ++this.pos\n      break\n    case 13:\n      if (this.input.charCodeAt(this.pos + 1) === 10) {\n        ++this.pos\n      }\n    case 10: case 8232: case 8233:\n      ++this.pos\n      if (this.options.locations) {\n        ++this.curLine\n        this.lineStart = this.pos\n      }\n      break\n    case 47: // '/'\n      switch (this.input.charCodeAt(this.pos + 1)) {\n      case 42: // '*'\n        this.skipBlockComment()\n        break\n      case 47:\n        this.skipLineComment(2)\n        break\n      default:\n        break loop\n      }\n      break\n    default:\n      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {\n        ++this.pos\n      } else {\n        break loop\n      }\n    }\n  }\n}\n\n// Called at the end of every token. Sets `end`, `val`, and\n// maintains `context` and `exprAllowed`, and skips the space after\n// the token, so that the next one's `start` will point at the\n// right position.\n\npp.finishToken = function(type, val) {\n  this.end = this.pos\n  if (this.options.locations) this.endLoc = this.curPosition()\n  let prevType = this.type\n  this.type = type\n  this.value = val\n\n  this.updateContext(prevType)\n}\n\n// ### Token reading\n\n// This is the function that is called to fetch the next token. It\n// is somewhat obscure, because it works in character codes rather\n// than characters, and because operator parsing has been inlined\n// into it.\n//\n// All in the name of speed.\n//\npp.readToken_dot = function() {\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next >= 48 && next <= 57) return this.readNumber(true)\n  let next2 = this.input.charCodeAt(this.pos + 2)\n  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'\n    this.pos += 3\n    return this.finishToken(tt.ellipsis)\n  } else {\n    ++this.pos\n    return this.finishToken(tt.dot)\n  }\n}\n\npp.readToken_slash = function() { // '/'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(tt.slash, 1)\n}\n\npp.readToken_mult_modulo_exp = function(code) { // '%*'\n  let next = this.input.charCodeAt(this.pos + 1)\n  let size = 1\n  let tokentype = code === 42 ? tt.star : tt.modulo\n\n  // exponentiation operator ** and **=\n  if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {\n    ++size\n    tokentype = tt.starstar\n    next = this.input.charCodeAt(this.pos + 2)\n  }\n\n  if (next === 61) return this.finishOp(tt.assign, size + 1)\n  return this.finishOp(tokentype, size)\n}\n\npp.readToken_pipe_amp = function(code) { // '|&'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2)\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1)\n}\n\npp.readToken_caret = function() { // '^'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(tt.bitwiseXOR, 1)\n}\n\npp.readToken_plus_min = function(code) { // '+-'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === code) {\n    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&\n        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {\n      // A `-->` line comment\n      this.skipLineComment(3)\n      this.skipSpace()\n      return this.nextToken()\n    }\n    return this.finishOp(tt.incDec, 2)\n  }\n  if (next === 61) return this.finishOp(tt.assign, 2)\n  return this.finishOp(tt.plusMin, 1)\n}\n\npp.readToken_lt_gt = function(code) { // '<>'\n  let next = this.input.charCodeAt(this.pos + 1)\n  let size = 1\n  if (next === code) {\n    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2\n    if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)\n    return this.finishOp(tt.bitShift, size)\n  }\n  if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&\n      this.input.charCodeAt(this.pos + 3) === 45) {\n    // `<!--`, an XML-style comment that should be interpreted as a line comment\n    this.skipLineComment(4)\n    this.skipSpace()\n    return this.nextToken()\n  }\n  if (next === 61) size = 2\n  return this.finishOp(tt.relational, size)\n}\n\npp.readToken_eq_excl = function(code) { // '=!'\n  let next = this.input.charCodeAt(this.pos + 1)\n  if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2)\n  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'\n    this.pos += 2\n    return this.finishToken(tt.arrow)\n  }\n  return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1)\n}\n\npp.getTokenFromCode = function(code) {\n  switch (code) {\n  // The interpretation of a dot depends on whether it is followed\n  // by a digit or another two dots.\n  case 46: // '.'\n    return this.readToken_dot()\n\n  // Punctuation tokens.\n  case 40: ++this.pos; return this.finishToken(tt.parenL)\n  case 41: ++this.pos; return this.finishToken(tt.parenR)\n  case 59: ++this.pos; return this.finishToken(tt.semi)\n  case 44: ++this.pos; return this.finishToken(tt.comma)\n  case 91: ++this.pos; return this.finishToken(tt.bracketL)\n  case 93: ++this.pos; return this.finishToken(tt.bracketR)\n  case 123: ++this.pos; return this.finishToken(tt.braceL)\n  case 125: ++this.pos; return this.finishToken(tt.braceR)\n  case 58: ++this.pos; return this.finishToken(tt.colon)\n  case 63: ++this.pos; return this.finishToken(tt.question)\n\n  case 96: // '`'\n    if (this.options.ecmaVersion < 6) break\n    ++this.pos\n    return this.finishToken(tt.backQuote)\n\n  case 48: // '0'\n    let next = this.input.charCodeAt(this.pos + 1)\n    if (next === 120 || next === 88) return this.readRadixNumber(16) // '0x', '0X' - hex number\n    if (this.options.ecmaVersion >= 6) {\n      if (next === 111 || next === 79) return this.readRadixNumber(8) // '0o', '0O' - octal number\n      if (next === 98 || next === 66) return this.readRadixNumber(2) // '0b', '0B' - binary number\n    }\n\n  // Anything else beginning with a digit is an integer, octal\n  // number, or float.\n  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9\n    return this.readNumber(false)\n\n  // Quotes produce strings.\n  case 34: case 39: // '\"', \"'\"\n    return this.readString(code)\n\n  // Operators are parsed inline in tiny state machines. '=' (61) is\n  // often referred to. `finishOp` simply skips the amount of\n  // characters it is given as second argument, and returns a token\n  // of the type given by its first argument.\n\n  case 47: // '/'\n    return this.readToken_slash()\n\n  case 37: case 42: // '%*'\n    return this.readToken_mult_modulo_exp(code)\n\n  case 124: case 38: // '|&'\n    return this.readToken_pipe_amp(code)\n\n  case 94: // '^'\n    return this.readToken_caret()\n\n  case 43: case 45: // '+-'\n    return this.readToken_plus_min(code)\n\n  case 60: case 62: // '<>'\n    return this.readToken_lt_gt(code)\n\n  case 61: case 33: // '=!'\n    return this.readToken_eq_excl(code)\n\n  case 126: // '~'\n    return this.finishOp(tt.prefix, 1)\n  }\n\n  this.raise(this.pos, \"Unexpected character '\" + codePointToString(code) + \"'\")\n}\n\npp.finishOp = function(type, size) {\n  let str = this.input.slice(this.pos, this.pos + size)\n  this.pos += size\n  return this.finishToken(type, str)\n}\n\npp.readRegexp = function() {\n  let escaped, inClass, start = this.pos\n  for (;;) {\n    if (this.pos >= this.input.length) this.raise(start, \"Unterminated regular expression\")\n    let ch = this.input.charAt(this.pos)\n    if (lineBreak.test(ch)) this.raise(start, \"Unterminated regular expression\")\n    if (!escaped) {\n      if (ch === \"[\") inClass = true\n      else if (ch === \"]\" && inClass) inClass = false\n      else if (ch === \"/\" && !inClass) break\n      escaped = ch === \"\\\\\"\n    } else escaped = false\n    ++this.pos\n  }\n  let pattern = this.input.slice(start, this.pos)\n  ++this.pos\n  let flagsStart = this.pos\n  let flags = this.readWord1()\n  if (this.containsEsc) this.unexpected(flagsStart)\n\n  // Validate pattern\n  const state = this.regexpState || (this.regexpState = new RegExpValidationState(this))\n  state.reset(start, pattern, flags)\n  this.validateRegExpFlags(state)\n  this.validateRegExpPattern(state)\n\n  // Create Literal#value property value.\n  let value = null\n  try {\n    value = new RegExp(pattern, flags)\n  } catch (e) {\n    // ESTree requires null if it failed to instantiate RegExp object.\n    // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral\n  }\n\n  return this.finishToken(tt.regexp, {pattern, flags, value})\n}\n\n// Read an integer in the given radix. Return null if zero digits\n// were read, the integer value otherwise. When `len` is given, this\n// will return `null` unless the integer has exactly `len` digits.\n\npp.readInt = function(radix, len) {\n  let start = this.pos, total = 0\n  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    let code = this.input.charCodeAt(this.pos), val\n    if (code >= 97) val = code - 97 + 10 // a\n    else if (code >= 65) val = code - 65 + 10 // A\n    else if (code >= 48 && code <= 57) val = code - 48 // 0-9\n    else val = Infinity\n    if (val >= radix) break\n    ++this.pos\n    total = total * radix + val\n  }\n  if (this.pos === start || len != null && this.pos - start !== len) return null\n\n  return total\n}\n\npp.readRadixNumber = function(radix) {\n  this.pos += 2 // 0x\n  let val = this.readInt(radix)\n  if (val == null) this.raise(this.start + 2, \"Expected number in radix \" + radix)\n  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, \"Identifier directly after number\")\n  return this.finishToken(tt.num, val)\n}\n\n// Read an integer, octal integer, or floating-point number.\n\npp.readNumber = function(startsWithDot) {\n  let start = this.pos\n  if (!startsWithDot && this.readInt(10) === null) this.raise(start, \"Invalid number\")\n  let octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48\n  if (octal && this.strict) this.raise(start, \"Invalid number\")\n  if (octal && /[89]/.test(this.input.slice(start, this.pos))) octal = false\n  let next = this.input.charCodeAt(this.pos)\n  if (next === 46 && !octal) { // '.'\n    ++this.pos\n    this.readInt(10)\n    next = this.input.charCodeAt(this.pos)\n  }\n  if ((next === 69 || next === 101) && !octal) { // 'eE'\n    next = this.input.charCodeAt(++this.pos)\n    if (next === 43 || next === 45) ++this.pos // '+-'\n    if (this.readInt(10) === null) this.raise(start, \"Invalid number\")\n  }\n  if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, \"Identifier directly after number\")\n\n  let str = this.input.slice(start, this.pos)\n  let val = octal ? parseInt(str, 8) : parseFloat(str)\n  return this.finishToken(tt.num, val)\n}\n\n// Read a string value, interpreting backslash-escapes.\n\npp.readCodePoint = function() {\n  let ch = this.input.charCodeAt(this.pos), code\n\n  if (ch === 123) { // '{'\n    if (this.options.ecmaVersion < 6) this.unexpected()\n    let codePos = ++this.pos\n    code = this.readHexChar(this.input.indexOf(\"}\", this.pos) - this.pos)\n    ++this.pos\n    if (code > 0x10FFFF) this.invalidStringToken(codePos, \"Code point out of bounds\")\n  } else {\n    code = this.readHexChar(4)\n  }\n  return code\n}\n\nfunction codePointToString(code) {\n  // UTF-16 Decoding\n  if (code <= 0xFFFF) return String.fromCharCode(code)\n  code -= 0x10000\n  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)\n}\n\npp.readString = function(quote) {\n  let out = \"\", chunkStart = ++this.pos\n  for (;;) {\n    if (this.pos >= this.input.length) this.raise(this.start, \"Unterminated string constant\")\n    let ch = this.input.charCodeAt(this.pos)\n    if (ch === quote) break\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos)\n      out += this.readEscapedChar(false)\n      chunkStart = this.pos\n    } else {\n      if (isNewLine(ch, this.options.ecmaVersion >= 10)) this.raise(this.start, \"Unterminated string constant\")\n      ++this.pos\n    }\n  }\n  out += this.input.slice(chunkStart, this.pos++)\n  return this.finishToken(tt.string, out)\n}\n\n// Reads template string tokens.\n\nconst INVALID_TEMPLATE_ESCAPE_ERROR = {}\n\npp.tryReadTemplateToken = function() {\n  this.inTemplateElement = true\n  try {\n    this.readTmplToken()\n  } catch (err) {\n    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {\n      this.readInvalidTemplateToken()\n    } else {\n      throw err\n    }\n  }\n\n  this.inTemplateElement = false\n}\n\npp.invalidStringToken = function(position, message) {\n  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {\n    throw INVALID_TEMPLATE_ESCAPE_ERROR\n  } else {\n    this.raise(position, message)\n  }\n}\n\npp.readTmplToken = function() {\n  let out = \"\", chunkStart = this.pos\n  for (;;) {\n    if (this.pos >= this.input.length) this.raise(this.start, \"Unterminated template\")\n    let ch = this.input.charCodeAt(this.pos)\n    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'\n      if (this.pos === this.start && (this.type === tt.template || this.type === tt.invalidTemplate)) {\n        if (ch === 36) {\n          this.pos += 2\n          return this.finishToken(tt.dollarBraceL)\n        } else {\n          ++this.pos\n          return this.finishToken(tt.backQuote)\n        }\n      }\n      out += this.input.slice(chunkStart, this.pos)\n      return this.finishToken(tt.template, out)\n    }\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos)\n      out += this.readEscapedChar(true)\n      chunkStart = this.pos\n    } else if (isNewLine(ch)) {\n      out += this.input.slice(chunkStart, this.pos)\n      ++this.pos\n      switch (ch) {\n      case 13:\n        if (this.input.charCodeAt(this.pos) === 10) ++this.pos\n      case 10:\n        out += \"\\n\"\n        break\n      default:\n        out += String.fromCharCode(ch)\n        break\n      }\n      if (this.options.locations) {\n        ++this.curLine\n        this.lineStart = this.pos\n      }\n      chunkStart = this.pos\n    } else {\n      ++this.pos\n    }\n  }\n}\n\n// Reads a template token to search for the end, without validating any escape sequences\npp.readInvalidTemplateToken = function() {\n  for (; this.pos < this.input.length; this.pos++) {\n    switch (this.input[this.pos]) {\n    case \"\\\\\":\n      ++this.pos\n      break\n\n    case \"$\":\n      if (this.input[this.pos + 1] !== \"{\") {\n        break\n      }\n    // falls through\n\n    case \"`\":\n      return this.finishToken(tt.invalidTemplate, this.input.slice(this.start, this.pos))\n\n    // no default\n    }\n  }\n  this.raise(this.start, \"Unterminated template\")\n}\n\n// Used to read escaped characters\n\npp.readEscapedChar = function(inTemplate) {\n  let ch = this.input.charCodeAt(++this.pos)\n  ++this.pos\n  switch (ch) {\n  case 110: return \"\\n\" // 'n' -> '\\n'\n  case 114: return \"\\r\" // 'r' -> '\\r'\n  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'\n  case 117: return codePointToString(this.readCodePoint()) // 'u'\n  case 116: return \"\\t\" // 't' -> '\\t'\n  case 98: return \"\\b\" // 'b' -> '\\b'\n  case 118: return \"\\u000b\" // 'v' -> '\\u000b'\n  case 102: return \"\\f\" // 'f' -> '\\f'\n  case 13: if (this.input.charCodeAt(this.pos) === 10) ++this.pos // '\\r\\n'\n  case 10: // ' \\n'\n    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine }\n    return \"\"\n  default:\n    if (ch >= 48 && ch <= 55) {\n      let octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0]\n      let octal = parseInt(octalStr, 8)\n      if (octal > 255) {\n        octalStr = octalStr.slice(0, -1)\n        octal = parseInt(octalStr, 8)\n      }\n      this.pos += octalStr.length - 1\n      ch = this.input.charCodeAt(this.pos)\n      if ((octalStr !== \"0\" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {\n        this.invalidStringToken(\n          this.pos - 1 - octalStr.length,\n          inTemplate\n            ? \"Octal literal in template string\"\n            : \"Octal literal in strict mode\"\n        )\n      }\n      return String.fromCharCode(octal)\n    }\n    if (isNewLine(ch)) {\n      // Unicode new line characters after \\ get removed from output in both\n      // template literals and strings\n      return \"\"\n    }\n    return String.fromCharCode(ch)\n  }\n}\n\n// Used to read character escape sequences ('\\x', '\\u', '\\U').\n\npp.readHexChar = function(len) {\n  let codePos = this.pos\n  let n = this.readInt(16, len)\n  if (n === null) this.invalidStringToken(codePos, \"Bad character escape sequence\")\n  return n\n}\n\n// Read an identifier, and return it as a string. Sets `this.containsEsc`\n// to whether the word contained a '\\u' escape.\n//\n// Incrementally adds only escaped chars, adding other chunks as-is\n// as a micro-optimization.\n\npp.readWord1 = function() {\n  this.containsEsc = false\n  let word = \"\", first = true, chunkStart = this.pos\n  let astral = this.options.ecmaVersion >= 6\n  while (this.pos < this.input.length) {\n    let ch = this.fullCharCodeAtPos()\n    if (isIdentifierChar(ch, astral)) {\n      this.pos += ch <= 0xffff ? 1 : 2\n    } else if (ch === 92) { // \"\\\"\n      this.containsEsc = true\n      word += this.input.slice(chunkStart, this.pos)\n      let escStart = this.pos\n      if (this.input.charCodeAt(++this.pos) !== 117) // \"u\"\n        this.invalidStringToken(this.pos, \"Expecting Unicode escape sequence \\\\uXXXX\")\n      ++this.pos\n      let esc = this.readCodePoint()\n      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))\n        this.invalidStringToken(escStart, \"Invalid Unicode escape\")\n      word += codePointToString(esc)\n      chunkStart = this.pos\n    } else {\n      break\n    }\n    first = false\n  }\n  return word + this.input.slice(chunkStart, this.pos)\n}\n\n// Read an identifier or keyword token. Will check for reserved\n// words when necessary.\n\npp.readWord = function() {\n  let word = this.readWord1()\n  let type = tt.name\n  if (this.keywords.test(word)) {\n    if (this.containsEsc) this.raiseRecoverable(this.start, \"Escape sequence in keyword \" + word)\n    type = keywordTypes[word]\n  }\n  return this.finishToken(type, word)\n}\n","// Acorn is a tiny, fast JavaScript parser written in JavaScript.\n//\n// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and\n// various contributors and released under an MIT license.\n//\n// Git repositories for Acorn are available at\n//\n//     http://marijnhaverbeke.nl/git/acorn\n//     https://github.com/acornjs/acorn.git\n//\n// Please use the [github bug tracker][ghbt] to report issues.\n//\n// [ghbt]: https://github.com/acornjs/acorn/issues\n//\n// [walk]: util/walk.js\n\nimport {Parser} from \"./state\"\nimport \"./parseutil\"\nimport \"./statement\"\nimport \"./lval\"\nimport \"./expression\"\nimport \"./location\"\nimport \"./scope\"\n\nexport {Parser} from \"./state\"\nexport {defaultOptions} from \"./options\"\nexport {Position, SourceLocation, getLineInfo} from \"./locutil\"\nexport {Node} from \"./node\"\nexport {TokenType, types as tokTypes, keywords as keywordTypes} from \"./tokentype\"\nexport {TokContext, types as tokContexts} from \"./tokencontext\"\nexport {isIdentifierChar, isIdentifierStart} from \"./identifier\"\nexport {Token} from \"./tokenize\"\nexport {isNewLine, lineBreak, lineBreakG, nonASCIIwhitespace} from \"./whitespace\"\n\nexport const version = \"6.1.1\"\n\n// The main exported interface (under `self.acorn` when in the\n// browser) is a `parse` function that takes a code string and\n// returns an abstract syntax tree as specified by [Mozilla parser\n// API][api].\n//\n// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API\n\nexport function parse(input, options) {\n  return Parser.parse(input, options)\n}\n\n// This function tries to parse a single expression at a given\n// offset in a string. Useful for parsing mixed-language formats\n// that embed JavaScript expressions.\n\nexport function parseExpressionAt(input, pos, options) {\n  return Parser.parseExpressionAt(input, pos, options)\n}\n\n// Acorn is organized as a tokenizer and a recursive-descent parser.\n// The `tokenizer` export provides an interface to the tokenizer.\n\nexport function tokenizer(input, options) {\n  return Parser.tokenizer(input, options)\n}\n"],"names":["const","let","keywords","tt","this","pp","init","label","node","empty","scope","types","UNICODE_PROPERTY_VALUES","codePointToString","ch","keywordTypes"],"mappings":"AAAA;;AAEA,AAAOA,IAAM,aAAa,GAAG;EAC3B,CAAC,EAAE,qNAAqN;EACxN,CAAC,EAAE,8CAA8C;EACjD,CAAC,EAAE,MAAM;EACT,MAAM,EAAE,wEAAwE;EAChF,UAAU,EAAE,gBAAgB;EAC7B;;;;AAIDA,IAAM,oBAAoB,GAAG,8KAA6K;;AAE1M,AAAOA,IAAM,QAAQ,GAAG;EACtB,CAAC,EAAE,oBAAoB;EACvB,CAAC,EAAE,oBAAoB,GAAG,0CAA0C;EACrE;;AAED,AAAOA,IAAM,yBAAyB,GAAG,kBAAiB;;;;;;;;;;AAU1DC,IAAI,4BAA4B,GAAG,4tIAA2tI;AAC9vIA,IAAI,uBAAuB,GAAG,sjFAAqjF;;AAEnlFD,IAAM,uBAAuB,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,4BAA4B,GAAG,GAAG,EAAC;AACpFA,IAAM,kBAAkB,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,4BAA4B,GAAG,uBAAuB,GAAG,GAAG,EAAC;;AAEzG,4BAA4B,GAAG,uBAAuB,GAAG,KAAI;;;;;;;;;AAS7DA,IAAM,0BAA0B,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAC;;;AAGvqCA,IAAM,qBAAqB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CA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"}
\ No newline at end of file
diff --git a/node_modules/acorn-globals/node_modules/acorn/dist/bin.js b/node_modules/acorn-globals/node_modules/acorn/dist/bin.js
new file mode 100644
index 0000000..eb0581d
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/dist/bin.js
@@ -0,0 +1,64 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var acorn = require('acorn');
+
+var infile, forceFile, silent = false, compact = false, tokenize = false;
+var options = {};
+
+function help(status) {
+  var print = (status === 0) ? console.log : console.error;
+  print("usage: " + path.basename(process.argv[1]) + " [--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|...|--ecma2015|--ecma2016|--ecma2017|--ecma2018|...]");
+  print("        [--tokenize] [--locations] [---allow-hash-bang] [--compact] [--silent] [--module] [--help] [--] [infile]");
+  process.exit(status);
+}
+
+for (var i = 2; i < process.argv.length; ++i) {
+  var arg = process.argv[i];
+  if ((arg === "-" || arg[0] !== "-") && !infile) { infile = arg; }
+  else if (arg === "--" && !infile && i + 2 === process.argv.length) { forceFile = infile = process.argv[++i]; }
+  else if (arg === "--locations") { options.locations = true; }
+  else if (arg === "--allow-hash-bang") { options.allowHashBang = true; }
+  else if (arg === "--silent") { silent = true; }
+  else if (arg === "--compact") { compact = true; }
+  else if (arg === "--help") { help(0); }
+  else if (arg === "--tokenize") { tokenize = true; }
+  else if (arg === "--module") { options.sourceType = "module"; }
+  else {
+    var match = arg.match(/^--ecma(\d+)$/);
+    if (match)
+      { options.ecmaVersion = +match[1]; }
+    else
+      { help(1); }
+  }
+}
+
+function run(code) {
+  var result;
+  try {
+    if (!tokenize) {
+      result = acorn.parse(code, options);
+    } else {
+      result = [];
+      var tokenizer = acorn.tokenizer(code, options), token;
+      do {
+        token = tokenizer.getToken();
+        result.push(token);
+      } while (token.type !== acorn.tokTypes.eof)
+    }
+  } catch (e) {
+    console.error(infile && infile !== "-" ? e.message.replace(/\(\d+:\d+\)$/, function (m) { return m.slice(0, 1) + infile + " " + m.slice(1); }) : e.message);
+    process.exit(1);
+  }
+  if (!silent) { console.log(JSON.stringify(result, null, compact ? null : 2)); }
+}
+
+if (forceFile || infile && infile !== "-") {
+  run(fs.readFileSync(infile, "utf8"));
+} else {
+  var code = "";
+  process.stdin.resume();
+  process.stdin.on("data", function (chunk) { return code += chunk; });
+  process.stdin.on("end", function () { return run(code); });
+}
diff --git a/node_modules/acorn-globals/node_modules/acorn/package.json b/node_modules/acorn-globals/node_modules/acorn/package.json
new file mode 100644
index 0000000..9736f35
--- /dev/null
+++ b/node_modules/acorn-globals/node_modules/acorn/package.json
@@ -0,0 +1,91 @@
+{
+  "_args": [
+    [
+      "acorn@^6.0.1",
+      "/home/taptap/WebstormProjects/bots/bots/taptap-optimum-bot/node_modules/jsdom/node_modules/acorn-globals"
+    ]
+  ],
+  "_from": "acorn@>=6.0.1 <7.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "acorn@6.4.1",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/jsdom/acorn-globals/acorn",
+  "_nodeVersion": "12.10.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/acorn_6.4.1_1583750346701_0.007352038532391303"
+  },
+  "_npmUser": {
+    "email": "marijnh@gmail.com",
+    "name": "marijn"
+  },
+  "_npmVersion": "6.13.4",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "acorn",
+    "raw": "acorn@^6.0.1",
+    "rawSpec": "^6.0.1",
+    "scope": null,
+    "spec": ">=6.0.1 <7.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/jsdom/acorn-globals"
+  ],
+  "_resolved": "https://registry.npmjs.org/acorn/-/acorn-6.4.1.tgz",
+  "_shasum": "531e58ba3f51b9dacb9a6646ca4debf5b14ca474",
+  "_shrinkwrap": null,
+  "_spec": "acorn@^6.0.1",
+  "_where": "/home/taptap/WebstormProjects/bots/bots/taptap-optimum-bot/node_modules/jsdom/node_modules/acorn-globals",
+  "bin": {
+    "acorn": "bin/acorn"
+  },
+  "bugs": {
+    "url": "https://github.com/acornjs/acorn/issues"
+  },
+  "dependencies": {},
+  "description": "ECMAScript parser",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "fileCount": 11,
+    "integrity": "sha512-ZVA9k326Nwrj3Cj9jlh3wGFutC2ZornPNARZwsNYqQYgN0EsV2d53w5RN/co65Ohn4sUAUtb1rSUAOD6XN9idA==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJeZhzLCRA9TVsSAnZWagAAF1kP/2i/8XA/1VgN23QMZt8E\nXFBEISdzGpeGDroNIoQwPPOdbCDCpeGeqCZiEciguHCG3sPgBQZiOeLyw7/T\n613RWrECUoW0ioFmYUypDdaIF5eTfk0lUGD6XlCYdSrZ29nA5jDIBpiv7DU4\n4p+bWx5Iq66rokCGmsWQr//1AoqkdNogl6Y4OVjoocTPjmzWEx1PRC5HtaWW\nFS+H8r3EYZLxOJByWTxt53SpI8UjvxmaXsFD/YUjvjzQVVQmW/lHfBCPorKO\ngK5XDunVhDg4KBwbkMlxthTHhjLAYzrwSnIrjLxtMVA+KabHBKhY3GeOhQE1\nksLKmbK9eiBRAHiKCylZdWGR3+TlLEzhT0umPve8BucL0ZRUEf2nEux+diaH\nqh8SbbvPcgprTESVWqaoV0+4ZK2laysvuU02agwPAX0SX7POtzYNbh8uzh6n\ndXgjsuffF76H2id2t6QqhEOy2lgmPxA1FRbFOrAi/UMq2cgSuiaDUuXK9jLn\nUdfbrjf2bHNtjSPnAwDFBXNGs1+jzU3V9QiWeQCtVzuIlnSfHr05kZJH+TmW\nMrKucR3Gw1dM2SOHEkrdIiyNcvePJ4+E57kd6aVjx+/PNIvBILzc3uPJwG4J\nXFW9tk4NIySLkL60euqr77J15SS8GDn++Dzkrk20OrTpxvIQguGM9HYX0bj6\ne36L\r\n=r2a9\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "531e58ba3f51b9dacb9a6646ca4debf5b14ca474",
+    "tarball": "https://registry.npmjs.org/acorn/-/acorn-6.4.1.tgz",
+    "unpackedSize": 1104023
+  },
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "homepage": "https://github.com/acornjs/acorn",
+  "license": "MIT",
+  "main": "dist/acorn.js",
+  "maintainers": [
+    {
+      "name": "adrianheine",
+      "email": "mail@adrianheine.de"
+    },
+    {
+      "name": "marijn",
+      "email": "marijnh@gmail.com"
+    },
+    {
+      "name": "rreverser",
+      "email": "me@rreverser.com"
+    }
+  ],
+  "module": "dist/acorn.mjs",
+  "name": "acorn",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acornjs/acorn.git"
+  },
+  "scripts": {
+    "prepare": "cd ..; npm run build:main && npm run build:bin"
+  },
+  "version": "6.4.1"
+}
diff --git a/node_modules/acorn-globals/package.json b/node_modules/acorn-globals/package.json
new file mode 100644
index 0000000..b5f24da
--- /dev/null
+++ b/node_modules/acorn-globals/package.json
@@ -0,0 +1,98 @@
+{
+  "_args": [
+    [
+      "acorn-globals@^4.3.4",
+      "/home/taptap/WebstormProjects/bots/bots/taptap-optimum-bot/node_modules/jsdom"
+    ]
+  ],
+  "_from": "acorn-globals@>=4.3.4 <5.0.0",
+  "_hasShrinkwrap": false,
+  "_id": "acorn-globals@4.3.4",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/jsdom/acorn-globals",
+  "_nodeVersion": "10.16.2",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/acorn-globals_4.3.4_1568130413087_0.8540497032448573"
+  },
+  "_npmUser": {
+    "email": "forbes@lindesay.co.uk",
+    "name": "forbeslindesay"
+  },
+  "_npmVersion": "6.9.0",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "acorn-globals",
+    "raw": "acorn-globals@^4.3.4",
+    "rawSpec": "^4.3.4",
+    "scope": null,
+    "spec": ">=4.3.4 <5.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/jsdom"
+  ],
+  "_resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-4.3.4.tgz",
+  "_shasum": "9fa1926addc11c97308c4e66d7add0d40c3272e7",
+  "_shrinkwrap": null,
+  "_spec": "acorn-globals@^4.3.4",
+  "_where": "/home/taptap/WebstormProjects/bots/bots/taptap-optimum-bot/node_modules/jsdom",
+  "author": {
+    "name": "ForbesLindesay"
+  },
+  "bugs": {
+    "url": "https://github.com/ForbesLindesay/acorn-globals/issues"
+  },
+  "dependencies": {
+    "acorn": "^6.0.1",
+    "acorn-walk": "^6.0.1"
+  },
+  "description": "Detect global variables in JavaScript using acorn",
+  "devDependencies": {
+    "testit": "^3.0.0"
+  },
+  "directories": {},
+  "dist": {
+    "fileCount": 4,
+    "integrity": "sha512-clfQEh21R+D0leSbUdWf3OcfqyaCSAQ8Ryq00bofSekfr9W8u1jyYZo6ir0xu9Gtcf7BjcHJpnbZH7JOCpP60A==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJdd8VtCRA9TVsSAnZWagAAnP4P/356XDWmY2o6n4siCvKH\nNtk3JNqAauchNGI9eIEj2OpPJvVI0F8xpDfsLPoYiPBN1b32TjQBl6hsvv/P\nIO0QcHbCugMNOh+u4aSn/bMiWgwZwqUVPAhZT+A15VhMeatu/Tr+t+T2SubV\nJBRfmw8xSp7c5DCdsIR9IoQy3ab5ZtaU8dOGnZcPYleSKbNFifQNnz7EdKSt\n8W0zh2cYReHkwl5BgQ9QSkaqPsOTrWi4Kq6B9xuPX2RCARfQCH8PrrcEXOIE\nu85u4/fMeFhARc9EYrWiHh3YFj1pHhO/7wvCdK522kvOglw/bjwtL9j5Pr19\nw4UFDccFyFnae+VpH2zirdKfnvzD8nBLzNmjOFL7SZnRDKye5bGAUceYqBLS\ncAnDp2Ig4LeungH+1khq8h+DyXEehhTAxgUPsYUgxhpheBBg7H43RHjdxgI7\nMAnWMdU+cOiTUSLGrSNGLwAyONrj8siZbfLbBhJn6D/RUoNo4iKj4kDl0Z6D\n9I12+nIUQyDQ5cax1kPdNAu5rtXUkP8Mux7dcJ6OTHIztSscuQfajRXniFRO\nHRYkibjrrcpF2xp0DVqnWgHX8MRPr7UXjK0+Ol7EDQAld+6ZZnkW5D1S6qIc\nwuU30tDNVnFOWa+iNawMRyklzQWrLm8xpag39wP/CX553CjYEnyYFkHlMW6T\nYc05\r\n=FXiy\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "9fa1926addc11c97308c4e66d7add0d40c3272e7",
+    "tarball": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-4.3.4.tgz",
+    "unpackedSize": 9102
+  },
+  "gitHead": "2f959b04c5f887eeda2f0341585979bc0722a1a3",
+  "homepage": "https://github.com/ForbesLindesay/acorn-globals#readme",
+  "keywords": [
+    "ast",
+    "global",
+    "implicit",
+    "lexical",
+    "local",
+    "name",
+    "scope",
+    "variable"
+  ],
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "forbeslindesay",
+      "email": "forbes@lindesay.co.uk"
+    },
+    {
+      "name": "timothygu",
+      "email": "timothygu99@gmail.com"
+    }
+  ],
+  "name": "acorn-globals",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForbesLindesay/acorn-globals.git"
+  },
+  "scripts": {
+    "test": "node test"
+  },
+  "version": "4.3.4"
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..555599a
--- /dev/null
+++ b/package.json
@@ -0,0 +1,195 @@
+{
+  "_args": [
+    [
+      "jsdom",
+      "/home/taptap/WebstormProjects/bots/bots/taptap-optimum-bot"
+    ]
+  ],
+  "_dependenciesComments": {
+    "parse5": "Pinned to exact version number because we monkeypatch its internals (see htmltodom.js)"
+  },
+  "_from": "jsdom@latest",
+  "_hasShrinkwrap": false,
+  "_id": "jsdom@16.2.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/jsdom",
+  "_nodeVersion": "13.6.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/jsdom_16.2.0_1581894164996_0.5973483790780283"
+  },
+  "_npmUser": {
+    "email": "d@domenic.me",
+    "name": "domenic"
+  },
+  "_npmVersion": "6.13.4",
+  "_phantomChildren": {
+    "acorn-walk": "6.2.0"
+  },
+  "_requested": {
+    "name": "jsdom",
+    "raw": "jsdom",
+    "rawSpec": "",
+    "scope": null,
+    "spec": "latest",
+    "type": "tag"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.2.0.tgz",
+  "_shasum": "fc171c305635046c100708b1c7ea7820ba015164",
+  "_shrinkwrap": null,
+  "_spec": "jsdom",
+  "_where": "/home/taptap/WebstormProjects/bots/bots/taptap-optimum-bot",
+  "browser": {
+    "./lib/jsdom/living/websockets/WebSocket-impl.js": "./lib/jsdom/living/websockets/WebSocket-impl-browser.js",
+    "canvas": false,
+    "vm": "./lib/jsdom/vm-shim.js"
+  },
+  "bugs": {
+    "url": "https://github.com/jsdom/jsdom/issues"
+  },
+  "dependencies": {
+    "abab": "^2.0.3",
+    "acorn": "^7.1.0",
+    "acorn-globals": "^4.3.4",
+    "cssom": "^0.4.4",
+    "cssstyle": "^2.2.0",
+    "data-urls": "^2.0.0",
+    "decimal.js": "^10.2.0",
+    "domexception": "^2.0.1",
+    "escodegen": "^1.13.0",
+    "html-encoding-sniffer": "^2.0.0",
+    "is-potential-custom-element-name": "^1.0.0",
+    "nwsapi": "^2.2.0",
+    "parse5": "5.1.1",
+    "request": "^2.88.0",
+    "request-promise-native": "^1.0.8",
+    "saxes": "^4.0.2",
+    "symbol-tree": "^3.2.4",
+    "tough-cookie": "^3.0.1",
+    "w3c-hr-time": "^1.0.1",
+    "w3c-xmlserializer": "^2.0.0",
+    "webidl-conversions": "^5.0.0",
+    "whatwg-encoding": "^1.0.5",
+    "whatwg-mimetype": "^2.3.0",
+    "whatwg-url": "^8.0.0",
+    "ws": "^7.2.1",
+    "xml-name-validator": "^3.0.0"
+  },
+  "description": "A JavaScript implementation of many web standards",
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "browserify": "^16.5.0",
+    "chai": "^4.2.0",
+    "eslint": "^6.8.0",
+    "eslint-find-rules": "^3.4.0",
+    "eslint-plugin-html": "^6.0.0",
+    "eslint-plugin-jsdom-internal": "link:./scripts/eslint-plugin",
+    "js-yaml": "^3.13.1",
+    "karma": "^4.4.1",
+    "karma-browserify": "^7.0.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-webworker": "^1.3.0",
+    "minimatch": "^3.0.4",
+    "mocha": "^7.0.1",
+    "mocha-sugar-free": "^1.4.0",
+    "optimist": "0.6.1",
+    "portfinder": "^1.0.25",
+    "rimraf": "^3.0.1",
+    "server-destroy": "^1.0.1",
+    "st": "^2.0.0",
+    "watchify": "^3.11.1",
+    "wd": "^1.12.1",
+    "webidl2js": "^14.0.0"
+  },
+  "directories": {},
+  "dist": {
+    "fileCount": 449,
+    "integrity": "sha512-6VaW3UWyKbm9DFVIAgTfhuwnvqiqlRYNg5Rk6dINTVoZT0eKz+N86vQZr+nqt1ny1lSB1TWZJWSEWQAfu8oTpA==",
+    "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJeScoVCRA9TVsSAnZWagAAXHwP/3e/fuRUOY5ohDz6MC7h\n8UQJsZksmXO4ysnNadiuhrf5M2FyYqOgqmR3yReJ6IG0sMvtec0DgfQlbE02\n7XjK7PmUP7U53I94ANdYrUSvpAlADFEQBKWnSSGND+CDb4tlly29ReqcCjoy\nKm69iogc5t9C7RnmyM8+ew6y6r6aQcjrtPOVm9O+hqux2z02XCJDFA5yUiNx\nx6s1gMZmVS0lr4tap4nApfnE/ZPOPBs/9Zjbj4LQrWyH64SJk2KrKR7aCCxr\nRgFgeE+YeAojFqg1mj3bnw995ncrhwH/9DXGP6GfOvPqtmcasAVYw69P+Xup\nErKLPr+Q4gkQDPWeFlMSPIiKT3Kp9Rg2Dn7F+c2/y7gyPzNH481CzgomaMYr\ng038Q/WStPF4vE8+SJdiPnqjlSqADNef05ayBnVCWeB+D55h0dCsYnOKY5KJ\nUPSUUwZarz/W2DwMXit+MZPk6XiML1TWVrmhYrG+GBQivR8Lrjcw70q58OxH\nRmhpU5IqMG/JmxnzHO9BrLb275+z2hXvZGmUGTYRjnoJOVjp/eCNFvvPBqha\nAAqlolULPBISQUiWg0I3L6zWj4go3wp7gKeE2Ha73B+2e9Znf8W9TdYZW5xL\nRaBg6Qp7XHmwOazwdKgdBEe1v6t7FuBeIKcHIDEJydscFhcNBoyp5HS30KxX\nmLiL\r\n=OEv6\r\n-----END PGP SIGNATURE-----\r\n",
+    "shasum": "fc171c305635046c100708b1c7ea7820ba015164",
+    "tarball": "https://registry.npmjs.org/jsdom/-/jsdom-16.2.0.tgz",
+    "unpackedSize": 2495705
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "gitHead": "493f63aea8152f5222bcb36cd46f18b5b1da62d0",
+  "homepage": "https://github.com/jsdom/jsdom#readme",
+  "keywords": [
+    "dom",
+    "html",
+    "w3c",
+    "whatwg"
+  ],
+  "license": "MIT",
+  "main": "lib/api.js",
+  "maintainers": [
+    {
+      "name": "domenic",
+      "email": "d@domenic.me"
+    },
+    {
+      "name": "joris-van-der-wel",
+      "email": "joris@jorisvanderwel.com"
+    },
+    {
+      "name": "sebmaster",
+      "email": "sebmaster16@gmail.com"
+    },
+    {
+      "name": "timothygu",
+      "email": "timothygu99@gmail.com"
+    },
+    {
+      "name": "tmpvar",
+      "email": "tmpvar@gmail.com"
+    },
+    {
+      "name": "zirro",
+      "email": "code@zirro.se"
+    }
+  ],
+  "name": "jsdom",
+  "optionalDependencies": {},
+  "peerDependencies": {
+    "canvas": "^2.5.0"
+  },
+  "peerDependenciesMeta": {
+    "canvas": {
+      "optional": true
+    }
+  },
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsdom/jsdom.git"
+  },
+  "scripts": {
+    "benchmark": "node ./benchmark/runner",
+    "benchmark-browser": "node ./benchmark/runner --bundle",
+    "convert-idl": "node ./scripts/webidl/convert.js",
+    "generate-js-globals": "node ./scripts/generate-js-globals.js",
+    "init-wpt": "git submodule update --init --recursive",
+    "lint": "eslint jsdom --cache --ext .js,.html",
+    "lint-is-complete": "eslint-find-rules --unused .eslintrc.json",
+    "prepare": "yarn convert-idl && yarn generate-js-globals",
+    "pretest": "yarn prepare && yarn init-wpt",
+    "reset-wpt": "rimraf ./test/web-platform-tests/tests && yarn init-wpt",
+    "test": "mocha test/index.js",
+    "test-api": "mocha test/api",
+    "test-browser": "yarn test-browser-iframe && yarn test-browser-worker",
+    "test-browser-iframe": "karma start test/karma.conf.js",
+    "test-browser-worker": "karma start test/karma-webworker.conf.js",
+    "test-mocha": "mocha",
+    "test-tuwpt": "mocha test/web-platform-tests/run-tuwpts.js",
+    "test-wpt": "mocha test/web-platform-tests/run-wpts.js",
+    "update-authors": "git log --format=\"%aN <%aE>\" | sort -f | uniq > AUTHORS.txt",
+    "update-wpt": "git submodule update --recursive --remote && cd test/web-platform-tests/tests && python wpt.py manifest --path ../wpt-manifest.json"
+  },
+  "version": "16.2.0"
+}