updated bunch of file paths and changed the way posts are loaded

node_modules/jsdom/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.

node_modules/jsdom/README.md

@@ -0,0 +1,539 @@
+# jsdom
+
+A JavaScript implementation of the WHATWG DOM and HTML standards, for use with [Node.js](https://nodejs.org/).
+
+## Install
+
+```bash
+$ npm install jsdom
+```
+
+Note that as of our 7.0.0 release, jsdom requires Node.js 4 or newer ([why?](https://github.com/tmpvar/jsdom/blob/master/Changelog.md#700)). In the meantime you are still welcome to install a release in [the 3.x series](https://github.com/tmpvar/jsdom/tree/3.x) if you use legacy Node.js versions like 0.10 or 0.12. There are also various releases between 3.x and 7.0.0 that work with various io.js versions.
+
+## Human contact
+
+- [Mailing list](http://groups.google.com/group/jsdom)
+- IRC channel: [#jsdom on freenode](irc://irc.freenode.net/jsdom)
+
+## Easymode: `jsdom.env`
+
+`jsdom.env` is an API that allows you to throw a bunch of stuff at it, and it will generally do the right thing.
+
+You can use it with a URL
+
+```js
+// Count all of the links from the io.js build page
+var jsdom = require("jsdom");
+
+jsdom.env(
+  "https://iojs.org/dist/",
+  ["http://code.jquery.com/jquery.js"],
+  function (err, window) {
+    console.log("there have been", window.$("a").length - 4, "io.js releases!");
+  }
+);
+```
+
+or with raw HTML
+
+```js
+// Run some jQuery on a html fragment
+var jsdom = require("jsdom");
+
+jsdom.env(
+  '<p><a class="the-link" href="https://github.com/tmpvar/jsdom">jsdom!</a></p>',
+  ["http://code.jquery.com/jquery.js"],
+  function (err, window) {
+    console.log("contents of a.the-link:", window.$("a.the-link").text());
+  }
+);
+```
+
+or with a configuration object
+
+```js
+// Print all of the news items on Hacker News
+var jsdom = require("jsdom");
+
+jsdom.env({
+  url: "http://news.ycombinator.com/",
+  scripts: ["http://code.jquery.com/jquery.js"],
+  done: function (err, window) {
+    var $ = window.$;
+    console.log("HN Links");
+    $("td.title:not(:last) a").each(function() {
+      console.log(" -", $(this).text());
+    });
+  }
+});
+```
+
+or with raw JavaScript source
+
+```js
+// Print all of the news items on Hacker News
+var jsdom = require("jsdom");
+var fs = require("fs");
+var jquery = fs.readFileSync("./path/to/jquery.js", "utf-8");
+
+jsdom.env({
+  url: "http://news.ycombinator.com/",
+  src: [jquery],
+  done: function (err, window) {
+    var $ = window.$;
+    console.log("HN Links");
+    $("td.title:not(:last) a").each(function () {
+      console.log(" -", $(this).text());
+    });
+  }
+});
+```
+
+### How it works
+
+The do-what-I-mean API is used like so:
+
+```js
+jsdom.env(string, [scripts], [config], callback);
+```
+
+- `string`: may be a URL, file name, or HTML fragment
+- `scripts`: a string or array of strings, containing file names or URLs that will be inserted as `<script>` tags
+- `config`: see below
+- `callback`: takes two arguments
+  - `err`: either `null`, if nothing goes wrong, or an error, if the window could not be created
+  - `window`: a brand new `window`, if there wasn't an error
+
+_Example:_
+
+```js
+jsdom.env(html, function (err, window) {
+  // free memory associated with the window
+  window.close();
+});
+```
+
+If you would like to specify a configuration object only:
+
+```js
+jsdom.env(config);
+```
+
+- `config.html`: a HTML fragment
+- `config.file`: a file which jsdom will load HTML from; the resulting window's `location.href` will be a `file://` URL.
+- `config.url`: sets the resulting window's `location.href`; if `config.html` and `config.file` are not provided, jsdom will load HTML from this URL.
+- `config.scripts`: see `scripts` above.
+- `config.src`: an array of JavaScript strings that will be evaluated against the resulting document. Similar to `scripts`, but it accepts JavaScript instead of paths/URLs.
+- `config.cookieJar`: cookie jar which will be used by document and related resource requests. Can be created by `jsdom.createCookieJar()` method. Useful to share cookie state among different documents as browsers does.
+- `config.parsingMode`: either `"auto"`, `"html"`, or `"xml"`. The default is `"auto"`, which uses HTML behavior unless `config.url` responds with an XML `Content-Type`, or `config.file` contains a filename ending in `.xml` or `.xhtml`. Setting to `"xml"` will attempt to parse the document as an XHTML document. (jsdom is [currently only OK at doing that](https://github.com/tmpvar/jsdom/issues/885).)
+- `config.referrer`: the new document will have this referrer.
+- `config.cookie`: manually set a cookie value, e.g. `'key=value; expires=Wed, Sep 21 2011 12:00:00 GMT; path=/'`. Accepts cookie string or array of cookie strings.
+- `config.headers`: an object giving any headers that will be used while loading the HTML from `config.url`, if applicable.
+- `config.userAgent`: the user agent string used in requests; defaults to `Node.js (#process.platform#; U; rv:#process.version#)`
+- `config.features`: see Flexibility section below. **Note**: the default feature set for `jsdom.env` does _not_ include fetching remote JavaScript and executing it. This is something that you will need to _carefully_ enable yourself.
+- `config.resourceLoader`: a function that intercepts subresource requests and allows you to re-route them, modify, or outright replace them with your own content. More below.
+- `config.done`, `config.onload`, `config.created`: see below.
+- `config.concurrentNodeIterators`: the maximum amount of `NodeIterator`s that you can use at the same time. The default is `10`; setting this to a high value will hurt performance.
+- `config.virtualConsole`: a virtual console instance that can capture the window’s console output; see the "Capturing Console Output" examples.
+- `config.pool`: an object describing which agents to use for the requests; defaults to `{ maxSockets: 6 }`, see [request module](https://github.com/request/request#requestoptions-callback) for more details.
+- `config.agentOptions`: the agent options; defaults to `{ keepAlive: true, keepAliveMsecs: 115000 }`, see [http api](https://nodejs.org/api/http.html) for more details.
+
+Note that at least one of the callbacks (`done`, `onload`, or `created`) is required, as is one of `html`, `file`, or `url`.
+
+### Initialization lifecycle
+
+If you just want to load the document and execute it, the `done` callback shown above is the simplest. If anything goes wrong while loading the document and creating the window, the problem will show up in the `error` passed as the first argument.
+
+However, if you want more control over or insight into the initialization lifecycle, you'll want to use the `created` and/or `loaded` callbacks:
+
+#### `created(error, window)`
+
+The `created` callback is called as soon as the window is created, or if that process fails. You may access all `window` properties here; however, `window.document` is not ready for use yet, as the HTML has not been parsed.
+
+The primary use-case for `created` is to modify the window object (e.g. add new functions on built-in prototypes) before any scripts execute.
+
+You can also set an event handler for `'load'` or other events on the window if you wish.
+
+If the `error` argument is non-`null`, it will contain whatever loading or initialization error caused the window creation to fail; in that case `window` will not be passed.
+
+#### `onload(window)`
+
+The `onload` callback is called along with the window's `'load'` event. This means it will only be called if creation succeeds without error. Note that by the time it has called, any external resources will have been downloaded, and any `<script>`s will have finished executing.
+
+#### `done(error, window)`
+
+Now that you know about `created` and `onload`, you can see that `done` is essentially both of them smashed together:
+
+- If window creation fails, then `error` will be the creation error.
+- Otherwise, `window` will be a fully-loaded window, with all external resources downloaded and `<script>`s executed.
+
+#### Dealing with asynchronous script loading
+
+If you load scripts asynchronously, e.g. with a module loader like RequireJS, none of the above hooks will really give you what you want. There's nothing, either in jsdom or in browsers, to say "notify me after all asynchronous loads have completed." The solution is to use the mechanisms of the framework you are using to notify about this finishing up. E.g., with RequireJS, you could do
+
+```js
+// On the Node.js/io.js side:
+var window = jsdom.jsdom(...).defaultView;
+window.onModulesLoaded = function () {
+  console.log("ready to roll!");
+};
+```
+
+```html
+<!-- Inside the HTML you supply to jsdom -->
+<script>
+requirejs(["entry-module"], function () {
+  window.onModulesLoaded();
+});
+</script>
+```
+
+For more details, see the discussion in [#640](https://github.com/tmpvar/jsdom/issues/640), especially [@matthewkastor](https://github.com/matthewkastor)'s [insightful comment](https://github.com/tmpvar/jsdom/issues/640#issuecomment-22216965).
+
+#### Listening for script errors during initialization
+
+Although it is easy to listen for script errors after initialization, via code like
+
+```js
+var window = jsdom.jsdom(...).defaultView;
+window.addEventListener("error", function (event) {
+  console.error("script error!!", event.error);
+});
+```
+
+it is often also desirable to listen for any script errors during initialization, or errors loading scripts passed to `jsdom.env`. To do this, use the virtual console feature, described in more detail later:
+
+```js
+var virtualConsole = jsdom.createVirtualConsole();
+virtualConsole.on("jsdomError", function (error) {
+  console.error(error.stack, error.detail);
+});
+
+var window = jsdom.jsdom(..., { virtualConsole }).defaultView;
+```
+
+You also get this functionality for free by default if you use `virtualConsole.sendTo`; again, see more below:
+
+```js
+var virtualConsole = jsdom.createVirtualConsole().sendTo(console);
+var window = jsdom.jsdom(..., { virtualConsole }).defaultView;
+```
+
+### On running scripts and being safe
+
+By default, `jsdom.env` will not process and run external JavaScript, since our sandbox is not foolproof. That is, code running inside the DOM's `<script>`s can, if it tries hard enough, get access to the Node environment, and thus to your machine. If you want to (carefully!) enable running JavaScript, you can use `jsdom.jsdom`, `jsdom.jQueryify`, or modify the defaults passed to `jsdom.env`.
+
+## For the hardcore: `jsdom.jsdom`
+
+The `jsdom.jsdom` method does fewer things automatically; it takes in only HTML source, and it does not allow you to separately supply scripts that it will inject and execute. It just gives you back a `document` object, with usable `document.defaultView`, and starts asynchronously executing any `<script>`s included in the HTML source. You can listen for the `'load'` event to wait until scripts are done loading and executing, just like you would in a normal HTML page.
+
+Usage of the API generally looks like this:
+
+```js
+var jsdom = require("jsdom").jsdom;
+var doc = jsdom(markup, options);
+var window = doc.defaultView;
+```
+
+- `markup` is a HTML document to be parsed. You can also pass `undefined` to get the basic document, equivalent to what a browser will give if you open up an empty `.html` file.
+
+- `options`: see the explanation of the `config` object above.
+
+### Flexibility
+
+One of the goals of jsdom is to be as minimal and light as possible. This section details how someone can change the behavior of `Document`s before they are created. These features are baked into the `DOMImplementation` that every `Document` has, and may be tweaked in two ways:
+
+1. When you create a new `Document`, by overriding the configuration:
+
+  ```js
+  var jsdom = require("jsdom").jsdom;
+  var doc = jsdom("<html><body></body></html>", {
+      features: {
+        FetchExternalResources : ["link"]
+      }
+  });
+  ```
+
+  Do note, that this will only affect the document that is currently being created. All other documents will use the defaults specified below (see: Default Features).
+
+2. Before creating any documents, you can modify the defaults for all future documents:
+
+  ```js
+  require("jsdom").defaultDocumentFeatures = {
+      FetchExternalResources: ["script"],
+      ProcessExternalResources: false
+  };
+  ```
+
+#### External Resources
+
+Default features are extremely important for jsdom as they lower the configuration requirement and present developers a set of consistent default behaviors. The following sections detail the available features, their defaults, and the values that jsdom uses.
+
+`FetchExternalResources`
+
+- _Default_: `["script"]`
+- _Allowed_: `["script", "frame", "iframe", "link"]` or `false`
+- _Default for `jsdom.env`_: `false`
+
+Enables/disables fetching files over the file system/HTTP
+
+`ProcessExternalResources`
+
+- _Default_: `["script"]`
+- _Allowed_: `["script"]` or `false`
+- _Default for `jsdom.env`_: `false`
+
+Enables/disables JavaScript execution
+
+`SkipExternalResources`
+
+- _Default_: `false` (allow all)
+- _Allowed_: `/url to be skipped/` or `false`
+- _Example_: `/http:\/\/example.org/js/bad\.js/`
+
+Filters resource downloading and processing to disallow those matching the given regular expression
+
+#### Custom External Resource Loader
+
+jsdom lets you intercept subresource requests using `config.resourceLoader`. `config.resourceLoader` expects a function which is called for each subresource request with the following arguments:
+
+- `resource`: a vanilla JavaScript object with the following properties
+  - `element`: the element that requested the resource.
+  - `url`: a parsed URL object.
+  - `cookie`: the content of the HTTP cookie header (`key=value` pairs separated by semicolons).
+  - `baseUrl`: the base URL used to resolve relative URLs.
+  - `defaultFetch(callback)`: a convenience method to fetch the resource online.
+- `callback`: a function to be called with two arguments
+  - `error`: either `null`, if nothing goes wrong, or an `Error` object.
+  - `body`: a string representing the body of the resource.
+
+For example, fetching all JS files from a different directory and running them in strict mode:
+
+```js
+var jsdom = require("jsdom");
+
+jsdom.env({
+  url: "http://example.com/",
+  resourceLoader: function (resource, callback) {
+    var pathname = resource.url.pathname;
+    if (/\.js$/.test(pathname)) {
+      resource.url.pathname = pathname.replace("/js/", "/js/raw/");
+      return resource.defaultFetch(function (err, body) {
+        if (err) return callback(err);
+        callback(null, '"use strict";\n' + body);
+      });
+    } else {
+      return resource.defaultFetch(callback);
+    }
+  },
+  features: {
+    FetchExternalResources: ["script"],
+    ProcessExternalResources: ["script"],
+    SkipExternalResources: false
+  }
+});
+```
+
+You can return an object containing an `abort()` function which will be called if the window is closed or stopped before the request ends.
+The `abort()` function should stop the request and call the callback with an error.
+
+For example, simulating a long request:
+
+```js
+var jsdom = require("jsdom");
+
+jsdom.env({
+  url: "http://example.com/",
+  resourceLoader: function (resource, callback) {
+    if (/\.json$/.test(pathname)) {
+      var timeout = setTimeout(function() {
+        callback(null, "{\"test\":\"test\"}");
+      }, 10000);
+      return {
+        abort: function() {
+          clearTimeout(timeout);
+          callback(new Error("request canceled by user"));
+        }
+      };
+    } else {
+      return resource.defaultFetch(callback);
+    }
+  },
+  features: {
+    FetchExternalResources: ["script"],
+    ProcessExternalResources: ["script"],
+    SkipExternalResources: false
+  }
+});
+```
+
+## Canvas
+
+jsdom includes support for using the [canvas](https://npmjs.org/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.
+
+## More Examples
+
+### Creating a browser-like window object
+
+```js
+var jsdom = require("jsdom").jsdom;
+var document = jsdom("hello world");
+var window = document.defaultView;
+
+console.log(window.document.documentElement.outerHTML);
+// output: "<html><head></head><body>hello world</body></html>"
+
+console.log(window.innerWidth);
+// output: 1024
+
+console.log(typeof window.document.getElementsByClassName);
+// outputs: function
+```
+
+### jQueryify
+
+```js
+var jsdom = require("jsdom");
+var window = jsdom.jsdom().defaultView;
+
+jsdom.jQueryify(window, "http://code.jquery.com/jquery-2.1.1.js", function () {
+  window.$("body").append('<div class="testing">Hello World, It works</div>');
+
+  console.log(window.$(".testing").text());
+});
+```
+
+### Passing objects to scripts inside the page
+
+```js
+var jsdom = require("jsdom").jsdom;
+var window = jsdom().defaultView;
+
+window.__myObject = { foo: "bar" };
+
+var scriptEl = window.document.createElement("script");
+scriptEl.src = "anotherScript.js";
+window.document.body.appendChild(scriptEl);
+
+// anotherScript.js will have the ability to read `window.__myObject`, even
+// though it originated in Node.js/io.js!
+```
+
+### Serializing a document
+
+```js
+var jsdom = require("jsdom").jsdom;
+var serializeDocument = require("jsdom").serializeDocument;
+
+var doc = jsdom("<!DOCTYPE html>hello");
+
+serializeDocument(doc) === "<!DOCTYPE html><html><head></head><body>hello</body></html>";
+doc.documentElement.outerHTML === "<html><head></head><body>hello</body></html>";
+```
+
+### Sharing cookie state among pages
+
+```js
+var jsdom = require("jsdom");
+var cookieJar = jsdom.createCookieJar();
+
+jsdom.env({
+    url: 'http://google.com',
+    cookieJar: cookieJar,
+    done: function (err1, window1) {
+        //...
+
+        jsdom.env({
+            url: 'http://code.google.com',
+            cookieJar: cookieJar,
+            done: function (err2, window2) {
+                //...
+            }
+        });
+    }
+});
+```
+
+### Capturing Console Output
+
+#### Forward a window's console output to the Node.js/io.js console
+
+```js
+var jsdom = require("jsdom");
+
+var document = jsdom.jsdom(undefined, {
+  virtualConsole: jsdom.createVirtualConsole().sendTo(console)
+});
+```
+
+By default this will forward all `"jsdomError"` events to `console.error`. If you want to maintain only a strict one-to-one mapping of events to method calls, and perhaps handle `"jsdomErrors"` yourself, then you can do `sendTo(console, { omitJsdomErrors: true })`.
+
+#### Create an event emitter for a window's console
+
+```js
+var jsdom = require("jsdom");
+
+var virtualConsole = jsdom.createVirtualConsole();
+
+virtualConsole.on("log", function (message) {
+  console.log("console.log called ->", message);
+});
+
+var document = jsdom.jsdom(undefined, {
+  virtualConsole: virtualConsole
+});
+```
+
+Post-initialization, if you didn't pass in a `virtualConsole` or no longer have a reference to it, you can retreive the `virtualConsole` by using:
+
+```js
+var virtualConsole = jsdom.getVirtualConsole(window);
+```
+
+#### Virtual console `jsdomError` error reporting
+
+Besides the usual events, corresponding to `console` methods, the virtual console is also used for reporting 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 external resources (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()`
+- Calls to methods, like `window.alert`, which jsdom does not implement, but installs anyway for web compatibility
+
+### Getting a node's location within the source
+
+To find where a DOM node is within the source document, we provide the `jsdom.nodeLocation` function:
+
+```js
+var jsdom = require("jsdom");
+
+var document = jsdom.jsdom(`<p>Hello
+    <img src="foo.jpg">
+  </p>`);
+
+var bodyEl = document.body; // implicitly created
+var pEl = document.querySelector("p");
+var textNode = pEl.firstChild;
+var imgEl = document.querySelector("img");
+
+console.log(jsdom.nodeLocation(bodyEl));   // null; it's not in the source
+console.log(jsdom.nodeLocation(pEl));      // { start: 0, end: 39, startTag: ..., endTag: ... }
+console.log(jsdom.nodeLocation(textNode)); // { start: 3, end: 13 }
+console.log(jsdom.nodeLocation(imgEl));    // { start: 13, end: 32 }
+```
+
+This returns the [parse5 location info](https://www.npmjs.com/package/parse5#options-locationinfo) for the node.
+
+#### Overriding `window.top`
+
+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 window, even using `Object.defineProperty`. However, if you're acting from outside the window, e.g. in some test framework that creates jsdom instances, you can override it using the special `jsdom.reconfigureWindow` function:
+
+```js
+jsdom.reconfigureWindow(window, { top: myFakeTopForTesting });
+```
+
+In the future we may expand `reconfigureWindow` to allow overriding other `[Unforgeable]` properties. Let us know if you need this capability.
+
+## What Standards Does jsdom Support, Exactly?
+
+Our mission is to get something very close to a headless browser, with emphasis more on the DOM/HTML side of things than the CSS side. As such, our primary goals are supporting [The DOM Standard](http://dom.spec.whatwg.org/) and [The HTML Standard](http://www.whatwg.org/specs/web-apps/current-work/multipage/). We only support some subset of these so far; in particular we have the subset covered by the outdated DOM 2 spec family down pretty well. We're slowly including more and more from the modern DOM and HTML specs, including some `Node` APIs, `querySelector(All)`, attribute semantics, the history and URL APIs, and the HTML parsing algorithm.
+
+We also support some subset of the [CSSOM](http://dev.w3.org/csswg/cssom/), largely via [@chad3814](https://github.com/chad3814)'s excellent [cssstyle](https://www.npmjs.org/package/cssstyle) package. In general we want to make webpages run headlessly as best we can, and if there are other specs we should be incorporating, let us know.

node_modules/jsdom/lib/README.md

@@ -0,0 +1,17 @@
+# Note: this codebase is in a transitional state
+
+We're slowly moving from a historical model based on layered "levels" of specs, to the [living standard model](https://wiki.whatwg.org/wiki/FAQ#What_does_.22Living_Standard.22_mean.3F) actually implemented by browsers. As such, the code is kind of a mess.
+
+**Summary**: new features go in `lib/jsdom/living` and follow the code style there; modifications to existing features will require some spelunking to find out what to modify in-place.
+
+---
+
+A lot of the main implementation is in `lib/jsdom/level1` and `lib/jsdom/level2`. (That includes things that didn't appear in the original DOM Level 1 and Level 2 specs, just because the code was located there and we had to patch it.) We're trying to avoid adding new code there, but patching old code is often still required.
+
+New features generally go in the `lib/jsdom/living` folder, in nice small files, with a clear coding style enforced by ESLint and JSCS.
+
+We're planning to fix this whole situation with a multi-stage process:
+
+- First, consolidate any leftovers in `lib/jsdom/browser` and `lib/jsdom/level3`, as well as the more substantial body of code in `lib/jsdom/level2`, into `lib/jsdom/level1`. This will contain the "historical" portion of the jsdom codebase.
+- Then, embark on a major cleanup and refactoring effort, splitting out small pieces from `lib/jsdom/level1` and into `lib/jsdom/living`, cleaning up the code style and spec compliance as we go.
+- Finally, collapse the silly directory hierarchy into something less nested.

node_modules/jsdom/lib/jsdom.js

@@ -0,0 +1,403 @@
+"use strict";
+/* eslint-disable no-unused-expressions */
+() => `jsdom 7.x onward only works on Node.js 4 or newer: https://github.com/tmpvar/jsdom#install`;
+/* eslint-enable no-unused-expressions */
+
+const fs = require("fs");
+const path = require("path");
+const CookieJar = require("tough-cookie").CookieJar;
+
+const toFileUrl = require("./jsdom/utils").toFileUrl;
+const defineGetter = require("./jsdom/utils").defineGetter;
+const defineSetter = require("./jsdom/utils").defineSetter;
+const documentFeatures = require("./jsdom/browser/documentfeatures");
+const domToHtml = require("./jsdom/browser/domtohtml").domToHtml;
+const Window = require("./jsdom/browser/Window");
+const resourceLoader = require("./jsdom/browser/resource-loader");
+const VirtualConsole = require("./jsdom/virtual-console");
+const locationInfo = require("./jsdom/living/helpers/internal-constants").locationInfo;
+
+require("./jsdom/living"); // Enable living standard features
+
+/* eslint-disable no-restricted-modules */
+// TODO: stop using the built-in URL in favor of the spec-compliant whatwg-url package
+// This legacy usage is in the process of being purged.
+const URL = require("url");
+/* eslint-enable no-restricted-modules */
+
+const canReadFilesFromFS = Boolean(fs.readFile); // in a browserify environment, this isn't present
+
+exports.createVirtualConsole = function (options) {
+  return new VirtualConsole(options);
+};
+
+exports.getVirtualConsole = function (window) {
+  return window._virtualConsole;
+};
+
+exports.createCookieJar = function () {
+  return new CookieJar(null, { looseMode: true });
+};
+
+exports.nodeLocation = function (node) {
+  return node[locationInfo];
+};
+
+exports.reconfigureWindow = function (window, newProps) {
+  if ("top" in newProps) {
+    window._top = newProps.top;
+  }
+};
+
+exports.debugMode = false;
+
+// Proxy feature functions to features module.
+for (const propName of ["availableDocumentFeatures", "defaultDocumentFeatures", "applyDocumentFeatures"]) {
+  defineGetter(exports, propName, () => documentFeatures[propName]);
+  defineSetter(exports, propName, val => documentFeatures[propName] = val);
+}
+
+exports.jsdom = function (html, options) {
+  if (options === undefined) {
+    options = {};
+  }
+  if (options.parsingMode === undefined || options.parsingMode === "auto") {
+    options.parsingMode = "html";
+  }
+
+  if (options.parsingMode !== "html" && options.parsingMode !== "xml") {
+    throw new RangeError(`Invalid parsingMode option ${JSON.stringify(options.parsingMode)}; must be either "html", ` +
+      `"xml", "auto", or undefined`);
+  }
+
+  setGlobalDefaultConfig(options);
+
+  // Back-compat hack: we have previously suggested nesting these under document, for jsdom.env at least.
+  // So we need to support that.
+  if (options.document) {
+    if (options.document.cookie !== undefined) {
+      options.cookie = options.document.cookie;
+    }
+    if (options.document.referrer !== undefined) {
+      options.referrer = options.document.referrer;
+    }
+  }
+
+  // List options explicitly to be clear which are passed through
+  const window = new Window({
+    parsingMode: options.parsingMode,
+    contentType: options.contentType,
+    parser: options.parser,
+    url: options.url,
+    referrer: options.referrer,
+    cookieJar: options.cookieJar,
+    cookie: options.cookie,
+    resourceLoader: options.resourceLoader,
+    deferClose: options.deferClose,
+    concurrentNodeIterators: options.concurrentNodeIterators,
+    virtualConsole: options.virtualConsole,
+    pool: options.pool,
+    agentOptions: options.agentOptions,
+    userAgent: options.userAgent
+  });
+
+  documentFeatures.applyDocumentFeatures(window.document, options.features);
+
+  if (options.created) {
+    options.created(null, window.document.defaultView);
+  }
+
+  if (options.parsingMode === "html") {
+    if (html === undefined || html === "") {
+      html = "<html><head></head><body></body></html>";
+    }
+
+    window.document.write(html);
+  }
+  if (options.parsingMode === "xml") {
+    if (html !== undefined) {
+      window.document._htmlToDom.appendHtmlToDocument(html, window.document);
+    }
+  }
+
+  if (window.document.close && !options.deferClose) {
+    window.document.close();
+  }
+
+  return window.document;
+};
+
+exports.jQueryify = exports.jsdom.jQueryify = function (window, jqueryUrl, callback) {
+  if (!window || !window.document) {
+    return;
+  }
+
+  const features = window.document.implementation._features;
+  window.document.implementation._addFeature("FetchExternalResources", ["script"]);
+  window.document.implementation._addFeature("ProcessExternalResources", ["script"]);
+  window.document.implementation._addFeature("MutationEvents", ["2.0"]);
+
+  const scriptEl = window.document.createElement("script");
+  scriptEl.className = "jsdom";
+  scriptEl.src = jqueryUrl;
+  scriptEl.onload = scriptEl.onerror = () => {
+    window.document.implementation._features = features;
+
+    if (callback) {
+      callback(window, window.jQuery);
+    }
+  };
+
+  window.document.body.appendChild(scriptEl);
+};
+
+exports.env = exports.jsdom.env = function () {
+  const config = getConfigFromArguments(arguments);
+  let req = null;
+
+  if (config.file && canReadFilesFromFS) {
+    req = resourceLoader.readFile(config.file, (err, text) => {
+      if (err) {
+        reportInitError(err, config);
+        return;
+      }
+
+      setParsingModeFromExtension(config, config.file);
+
+      config.html = text;
+      processHTML(config);
+    });
+  } else if (config.html !== undefined) {
+    processHTML(config);
+  } else if (config.url) {
+    req = handleUrl(config);
+  } else if (config.somethingToAutodetect !== undefined) {
+    const url = URL.parse(config.somethingToAutodetect);
+    if (url.protocol && url.hostname) {
+      config.url = config.somethingToAutodetect;
+      req = handleUrl(config.somethingToAutodetect);
+    } else if (canReadFilesFromFS) {
+      req = resourceLoader.readFile(config.somethingToAutodetect, (err, text) => {
+        if (err) {
+          if (err.code === "ENOENT" || err.code === "ENAMETOOLONG") {
+            config.html = config.somethingToAutodetect;
+            processHTML(config);
+          } else {
+            reportInitError(err, config);
+          }
+        } else {
+          setParsingModeFromExtension(config, config.somethingToAutodetect);
+
+          config.html = text;
+          config.url = toFileUrl(config.somethingToAutodetect);
+          processHTML(config);
+        }
+      });
+    } else {
+      config.html = config.somethingToAutodetect;
+      processHTML(config);
+    }
+  }
+
+  function handleUrl() {
+    const options = {
+      encoding: config.encoding || "utf8",
+      headers: config.headers || {},
+      pool: config.pool,
+      agentOptions: config.agentOptions
+    };
+
+    if (config.proxy) {
+      options.proxy = config.proxy;
+    }
+
+    options.headers["User-Agent"] = config.userAgent;
+
+    config.cookieJar = config.cookieJar || exports.createCookieJar();
+
+    return resourceLoader.download(config.url, options, config.cookieJar, null, (err, responseText, res) => {
+      if (err) {
+        reportInitError(err, config);
+        return;
+      }
+
+      // The use of `res.request.uri.href` ensures that `window.location.href`
+      // is updated when `request` follows redirects.
+      config.html = responseText;
+      config.url = res.request.uri.href;
+
+      const contentType = res.headers["content-type"];
+
+      if (config.parsingMode === "auto" && (
+        contentType === "application/xml" ||
+        contentType === "text/xml" ||
+        contentType === "application/xhtml+xml")) {
+        config.parsingMode = "xml";
+      }
+
+      processHTML(config);
+    });
+  }
+  return req;
+};
+
+exports.serializeDocument = function (doc) {
+  return domToHtml([doc]);
+};
+
+function processHTML(config) {
+  const window = exports.jsdom(config.html, config).defaultView;
+  const features = JSON.parse(JSON.stringify(window.document.implementation._features));
+
+  let docsLoaded = 0;
+  const totalDocs = config.scripts.length + config.src.length;
+
+  if (!window || !window.document) {
+    reportInitError(new Error("JSDOM: a window object could not be created."), config);
+    return;
+  }
+
+  function scriptComplete() {
+    docsLoaded++;
+
+    if (docsLoaded >= totalDocs) {
+      window.document.implementation._features = features;
+
+      process.nextTick(() => {
+        if (config.onload) {
+          config.onload(window);
+        }
+        if (config.done) {
+          config.done(null, window);
+        }
+      });
+    }
+  }
+
+  function handleScriptError() {
+    // nextTick so that an exception within scriptComplete won't cause
+    // another script onerror (which would be an infinite loop)
+    process.nextTick(scriptComplete);
+  }
+
+  if (config.scripts.length > 0 || config.src.length > 0) {
+    window.document.implementation._addFeature("FetchExternalResources", ["script"]);
+    window.document.implementation._addFeature("ProcessExternalResources", ["script"]);
+    window.document.implementation._addFeature("MutationEvents", ["2.0"]);
+
+    for (const scriptSrc of config.scripts) {
+      const script = window.document.createElement("script");
+      script.className = "jsdom";
+      script.onload = scriptComplete;
+      script.onerror = handleScriptError;
+      script.src = scriptSrc;
+
+      window.document.body.appendChild(script);
+    }
+
+    for (const scriptText of config.src) {
+      const script = window.document.createElement("script");
+      script.onload = scriptComplete;
+      script.onerror = handleScriptError;
+      script.text = scriptText;
+
+      window.document.documentElement.appendChild(script);
+      window.document.documentElement.removeChild(script);
+    }
+  } else if (window.document.readyState === "complete") {
+    scriptComplete();
+  } else {
+    window.addEventListener("load", scriptComplete);
+  }
+}
+
+function setGlobalDefaultConfig(config) {
+  config.pool = config.pool !== undefined ? config.pool : {
+    maxSockets: 6
+  };
+
+  config.agentOptions = config.agentOptions !== undefined ? config.agentOptions : {
+    keepAlive: true,
+    keepAliveMsecs: 115 * 1000
+  };
+
+  config.userAgent = config.userAgent || "Node.js (" + process.platform + "; U; rv:" + process.version + ")";
+}
+
+function getConfigFromArguments(args) {
+  const config = {};
+  if (typeof args[0] === "object") {
+    Object.assign(config, args[0]);
+  } else {
+    for (const arg of args) {
+      switch (typeof arg) {
+        case "string":
+          config.somethingToAutodetect = arg;
+          break;
+        case "function":
+          config.done = arg;
+          break;
+        case "object":
+          if (Array.isArray(arg)) {
+            config.scripts = arg;
+          } else {
+            Object.assign(config, arg);
+          }
+          break;
+      }
+    }
+  }
+
+  if (!config.done && !config.created && !config.onload) {
+    throw new Error("Must pass a \"created\", \"onload\", or \"done\" option, or a callback, to jsdom.env");
+  }
+
+  if (config.somethingToAutodetect === undefined &&
+      config.html === undefined && !config.file && !config.url) {
+    throw new Error("Must pass a \"html\", \"file\", or \"url\" option, or a string, to jsdom.env");
+  }
+
+  config.scripts = ensureArray(config.scripts);
+  config.src = ensureArray(config.src);
+  config.parsingMode = config.parsingMode || "auto";
+
+  config.features = config.features || {
+    FetchExternalResources: false,
+    ProcessExternalResources: false,
+    SkipExternalResources: false
+  };
+
+  if (!config.url && config.file) {
+    config.url = toFileUrl(config.file);
+  }
+
+  setGlobalDefaultConfig(config);
+
+  return config;
+}
+
+function reportInitError(err, config) {
+  if (config.created) {
+    config.created(err);
+  }
+  if (config.done) {
+    config.done(err);
+  }
+}
+
+function ensureArray(value) {
+  let array = value || [];
+  if (typeof array === "string") {
+    array = [array];
+  }
+  return array;
+}
+
+function setParsingModeFromExtension(config, filename) {
+  if (config.parsingMode === "auto") {
+    const ext = path.extname(filename);
+    if (ext === ".xhtml" || ext === ".xml") {
+      config.parsingMode = "xml";
+    }
+  }
+}

node_modules/jsdom/lib/jsdom/browser/Window.js

@@ -0,0 +1,424 @@
+"use strict";
+
+const CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
+const notImplemented = require("./not-implemented");
+const History = require("./history");
+const VirtualConsole = require("../virtual-console");
+const define = require("../utils").define;
+const inherits = require("../utils").inheritFrom;
+const EventTarget = require("../living/generated/EventTarget");
+const namedPropertiesWindow = require("../living/named-properties-window");
+const cssom = require("cssom");
+const postMessage = require("../living/post-message");
+const DOMException = require("../web-idl/DOMException");
+const btoa = require("abab").btoa;
+const atob = require("abab").atob;
+const idlUtils = require("../living/generated/utils");
+const internalConstants = require("../living/helpers/internal-constants");
+const createFileReader = require("../living/file-reader");
+const createXMLHttpRequest = require("../living/xmlhttprequest");
+
+// NB: the require() must be after assigning `module.export` because this require() is circular
+module.exports = Window;
+const dom = require("../living");
+
+const cssSelectorSplitRE = /((?:[^,"']|"[^"]*"|'[^']*')+)/;
+
+const defaultStyleSheet = cssom.parse(require("./default-stylesheet"));
+
+dom.Window = Window;
+
+// 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) {
+  EventTarget.setup(this);
+
+  const window = this;
+
+  ///// INTERFACES FROM THE DOM
+  // TODO: consider a mode of some sort where these are not shared between all DOM instances
+  // It'd be very memory-expensive in most cases, though.
+  define(window, dom);
+
+  ///// PRIVATE DATA PROPERTIES
+
+  // vm initialization is defered until script processing is activated (in level1/core)
+  this._globalProxy = this;
+
+  this.__timers = [];
+
+  // List options explicitly to be clear which are passed through
+  this._document = new dom.HTMLDocument({
+    parsingMode: options.parsingMode,
+    contentType: options.contentType,
+    cookieJar: options.cookieJar,
+    parser: options.parser,
+    url: options.url,
+    referrer: options.referrer,
+    cookie: options.cookie,
+    deferClose: options.deferClose,
+    resourceLoader: options.resourceLoader,
+    concurrentNodeIterators: options.concurrentNodeIterators,
+    pool: options.pool,
+    agentOptions: options.agentOptions,
+    userAgent: options.userAgent,
+    defaultView: this._globalProxy,
+    global: this
+  });
+
+
+  // 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 implements window.frames.length, since window.frames returns a
+  // self reference to the window object.  This value is incremented in the
+  // HTMLFrameElement init function (see: level2/html.js).
+  this._length = 0;
+
+  if (options.virtualConsole) {
+    if (options.virtualConsole instanceof VirtualConsole) {
+      this._virtualConsole = options.virtualConsole;
+    } else {
+      throw new TypeError(
+        "options.virtualConsole must be a VirtualConsole (from createVirtualConsole)");
+    }
+  } else {
+    this._virtualConsole = new VirtualConsole();
+  }
+
+  ///// GETTERS
+
+  define(this, {
+    get length() {
+      return window._length;
+    },
+    get window() {
+      return window._globalProxy;
+    },
+    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 location() {
+      return window._document._location;
+    }
+  });
+
+  namedPropertiesWindow.initializeWindow(this, dom.HTMLCollection);
+
+  ///// 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
+
+  this.setTimeout = function (fn, ms) {
+    return startTimer(window, setTimeout, clearTimeout, fn, ms);
+  };
+  this.setInterval = function (fn, ms) {
+    return startTimer(window, setInterval, clearInterval, fn, ms);
+  };
+  this.clearInterval = stopTimer.bind(this, window);
+  this.clearTimeout = stopTimer.bind(this, window);
+  this.__stopAllTimers = stopAllTimers.bind(this, window);
+
+  this.Image = function (width, height) {
+    const element = window._document.createElement("img");
+    element.width = width;
+    element.height = height;
+    return element;
+  };
+
+  function wrapConsoleMethod(method) {
+    return function () {
+      const args = Array.prototype.slice.call(arguments);
+      window._virtualConsole.emit.apply(window._virtualConsole, [method].concat(args));
+    };
+  }
+
+  this.postMessage = postMessage;
+
+  this.atob = function (str) {
+    const result = atob(str);
+    if (result === null) {
+      throw new DOMException(DOMException.INVALID_CHARACTER_ERR,
+        "The string to be decoded contains invalid characters.");
+    }
+    return result;
+  };
+
+  this.btoa = function (str) {
+    const result = btoa(str);
+    if (result === null) {
+      throw new DOMException(DOMException.INVALID_CHARACTER_ERR,
+        "The string to be encoded contains invalid characters.");
+    }
+    return result;
+  };
+
+  this.FileReader = createFileReader(this);
+  this.XMLHttpRequest = createXMLHttpRequest(this);
+
+  // TODO: necessary for Blob and FileReader due to different-globals weirdness; investigate how to avoid this.
+  this.ArrayBuffer = ArrayBuffer;
+  this.Int8Array = Int8Array;
+  this.Uint8Array = Uint8Array;
+  this.Uint8ClampedArray = Uint8ClampedArray;
+  this.Int16Array = Int16Array;
+  this.Uint16Array = Uint16Array;
+  this.Int32Array = Int32Array;
+  this.Uint32Array = Uint32Array;
+  this.Float32Array = Float32Array;
+  this.Float64Array = Float64Array;
+
+  this.stop = function () {
+    if (this._document[internalConstants.requestManager]) {
+      this._document[internalConstants.requestManager].close();
+    }
+  };
+
+  this.close = function () {
+    // Recursively close child frame windows, then ourselves.
+    const currentWindow = this;
+    (function windowCleaner(windowToClean) {
+      for (let i = 0; i < windowToClean.length; i++) {
+        windowCleaner(windowToClean[i]);
+      }
+
+      // We"re already in our own window.close().
+      if (windowToClean !== currentWindow) {
+        windowToClean.close();
+      }
+    }(this));
+
+    // 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.
+        this._document._listeners = Object.create(null);
+        this._document.close();
+      }
+      const doc = this._document;
+      delete this._document;
+      // Stops the connections after document deletion because the listeners will not be triggered once document deleted
+      if (doc[internalConstants.requestManager]) {
+        doc[internalConstants.requestManager].close();
+      }
+    }
+
+    stopAllTimers(currentWindow);
+  };
+
+  this.getComputedStyle = function (node) {
+    const s = node.style;
+    const cs = new CSSStyleDeclaration();
+    const forEach = Array.prototype.forEach;
+
+    function setPropertiesFromRule(rule) {
+      if (!rule.selectorText) {
+        return;
+      }
+
+      const selectors = rule.selectorText.split(cssSelectorSplitRE);
+      let matched = false;
+      for (const selectorText of selectors) {
+        if (selectorText !== "" && selectorText !== "," && !matched && matchesDontThrow(node, selectorText)) {
+          matched = true;
+          forEach.call(rule.style, property => {
+            cs.setProperty(property, rule.style.getPropertyValue(property), rule.style.getPropertyPriority(property));
+          });
+        }
+      }
+    }
+
+    function readStylesFromStyleSheet(sheet) {
+      forEach.call(sheet.cssRules, rule => {
+        if (rule.media) {
+          if (Array.prototype.indexOf.call(rule.media, "screen") !== -1) {
+            forEach.call(rule.cssRules, setPropertiesFromRule);
+          }
+        } else {
+          setPropertiesFromRule(rule);
+        }
+      });
+    }
+
+    readStylesFromStyleSheet(defaultStyleSheet);
+    forEach.call(node.ownerDocument.styleSheets, readStylesFromStyleSheet);
+
+    forEach.call(s, property => {
+      cs.setProperty(property, s.getPropertyValue(property), s.getPropertyPriority(property));
+    });
+
+    return cs;
+  };
+
+  ///// PUBLIC DATA PROPERTIES (TODO: should be getters)
+
+  this.history = new History(this);
+
+  this.console = {
+    assert: wrapConsoleMethod("assert"),
+    clear: wrapConsoleMethod("clear"),
+    count: wrapConsoleMethod("count"),
+    debug: wrapConsoleMethod("debug"),
+    error: wrapConsoleMethod("error"),
+    group: wrapConsoleMethod("group"),
+    groupCollapse: wrapConsoleMethod("groupCollapse"),
+    groupEnd: wrapConsoleMethod("groupEnd"),
+    info: wrapConsoleMethod("info"),
+    log: wrapConsoleMethod("log"),
+    table: wrapConsoleMethod("table"),
+    time: wrapConsoleMethod("time"),
+    timeEnd: wrapConsoleMethod("timeEnd"),
+    trace: wrapConsoleMethod("trace"),
+    warn: wrapConsoleMethod("warn")
+  };
+
+  function notImplementedMethod(name) {
+    return function () {
+      notImplemented(name, window);
+    };
+  }
+
+  define(this, {
+    navigator: {
+      get userAgent() {
+        return options.userAgent;
+      },
+      get appName() {
+        return "Node.js jsDom";
+      },
+      get platform() {
+        return process.platform;
+      },
+      get appVersion() {
+        return process.version;
+      },
+      noUI: true,
+      get cookieEnabled() {
+        return true;
+      }
+    },
+
+    name: "nodejs",
+    innerWidth: 1024,
+    innerHeight: 768,
+    outerWidth: 1024,
+    outerHeight: 768,
+    pageXOffset: 0,
+    pageYOffset: 0,
+    screenX: 0,
+    screenY: 0,
+    screenLeft: 0,
+    screenTop: 0,
+    scrollX: 0,
+    scrollY: 0,
+    scrollTop: 0,
+    scrollLeft: 0,
+    screen: {
+      width: 0,
+      height: 0
+    },
+
+    alert: notImplementedMethod("window.alert"),
+    blur: notImplementedMethod("window.blur"),
+    confirm: notImplementedMethod("window.confirm"),
+    createPopup: notImplementedMethod("window.createPopup"),
+    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"),
+
+    toString: () => {
+      return "[object Window]";
+    }
+  });
+
+  ///// INITIALIZATION
+
+  process.nextTick(() => {
+    if (!window.document) {
+      return; // window might've been closed already
+    }
+
+    if (window.document.readyState === "complete") {
+      const ev = window.document.createEvent("HTMLEvents");
+      ev.initEvent("load", false, false);
+      window.dispatchEvent(ev);
+    } else {
+      window.document.addEventListener("load", () => {
+        const ev = window.document.createEvent("HTMLEvents");
+        ev.initEvent("load", false, false);
+        window.dispatchEvent(ev);
+      });
+    }
+  });
+}
+
+inherits(EventTarget.interface, Window, EventTarget.interface.prototype);
+
+function matchesDontThrow(el, selector) {
+  try {
+    return el.matches(selector);
+  } catch (e) {
+    return false;
+  }
+}
+
+function startTimer(window, startFn, stopFn, callback, ms) {
+  const res = startFn(callback, ms);
+  window.__timers.push([res, stopFn]);
+  return res;
+}
+
+function stopTimer(window, id) {
+  if (typeof id === "undefined") {
+    return;
+  }
+  for (const i in window.__timers) {
+    if (window.__timers[i][0] === id) {
+      window.__timers[i][1].call(window, id);
+      window.__timers.splice(i, 1);
+      break;
+    }
+  }
+}
+
+function stopAllTimers(window) {
+  for (const t of window.__timers) {
+    t[1].call(window, t[0]);
+  }
+  window.__timers = [];
+}
+

node_modules/jsdom/lib/jsdom/browser/documentAdapter.js

@@ -0,0 +1,65 @@
+"use strict";
+
+// Tree traversing
+exports.getFirstChild = function (node) {
+  return node.childNodes[0];
+};
+
+exports.getChildNodes = function (node) {
+  // parse5 treats template elements specially, assuming you return an array whose single item is the document fragment
+  return node._templateContents ? [node._templateContents] : node.childNodes;
+};
+
+exports.getParentNode = function (node) {
+  return node.parentNode;
+};
+
+exports.getAttrList = function (node) {
+  return node.attributes;
+};
+
+// Node data
+exports.getTagName = function (element) {
+  return element.tagName.toLowerCase();
+};
+
+exports.getNamespaceURI = function (element) {
+  return element.namespaceURI || "http://www.w3.org/1999/xhtml";
+};
+
+exports.getTextNodeContent = function (textNode) {
+  return textNode.nodeValue;
+};
+
+exports.getCommentNodeContent = function (commentNode) {
+  return commentNode.nodeValue;
+};
+
+exports.getDocumentTypeNodeName = function (doctypeNode) {
+  return doctypeNode.name;
+};
+
+exports.getDocumentTypeNodePublicId = function (doctypeNode) {
+  return doctypeNode.publicId || null;
+};
+
+exports.getDocumentTypeNodeSystemId = function (doctypeNode) {
+  return doctypeNode.systemId || null;
+};
+
+// Node types
+exports.isTextNode = function (node) {
+  return node.nodeName === "#text";
+};
+
+exports.isCommentNode = function (node) {
+  return node.nodeName === "#comment";
+};
+
+exports.isDocumentTypeNode = function (node) {
+  return node.nodeType === 10;
+};
+
+exports.isElementNode = function (node) {
+  return Boolean(node.tagName);
+};

node_modules/jsdom/lib/jsdom/browser/documentfeatures.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.availableDocumentFeatures = [
+  "FetchExternalResources",
+  "ProcessExternalResources",
+  "MutationEvents",
+  "SkipExternalResources"
+];
+
+exports.defaultDocumentFeatures = {
+  FetchExternalResources: ["script", "link"], // omitted by default: "frame"
+  ProcessExternalResources: ["script"], // omitted by default: "frame", "iframe"
+  MutationEvents: "2.0",
+  SkipExternalResources: false
+};
+
+exports.applyDocumentFeatures = function (doc, features) {
+  features = features || {};
+
+  for (let i = 0; i < exports.availableDocumentFeatures.length; ++i) {
+    const featureName = exports.availableDocumentFeatures[i];
+    let featureSource;
+
+    if (features[featureName] !== undefined) {
+      featureSource = features[featureName];
+      // We have to check the lowercase version also because the Document feature
+      // methods convert everything to lowercase.
+    } else if (typeof features[featureName.toLowerCase()] !== "undefined") {
+      featureSource = features[featureName.toLowerCase()];
+    } else if (exports.defaultDocumentFeatures[featureName]) {
+      featureSource = exports.defaultDocumentFeatures[featureName];
+    } else {
+      continue;
+    }
+
+    doc.implementation._removeFeature(featureName);
+
+    if (featureSource !== undefined) {
+      if (Array.isArray(featureSource)) {
+        for (let j = 0; j < featureSource.length; ++j) {
+          doc.implementation._addFeature(featureName, featureSource[j]);
+        }
+      } else {
+        doc.implementation._addFeature(featureName, featureSource);
+      }
+    }
+  }
+};

node_modules/jsdom/lib/jsdom/browser/domtohtml.js

@@ -0,0 +1,18 @@
+"use strict";
+const parse5 = require("parse5");
+const documentAdapter = require("./documentAdapter");
+const NODE_TYPE = require("../living/node-type");
+
+const serializer = new parse5.TreeSerializer(documentAdapter);
+
+exports.domToHtml = function (iterable) {
+  let ret = "";
+  for (const node of iterable) {
+    if (node.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+      ret += serializer.serialize(node);
+    } else {
+      ret += serializer.serialize({ childNodes: [node] });
+    }
+  }
+  return ret;
+};

node_modules/jsdom/lib/jsdom/browser/history.js

@@ -0,0 +1,92 @@
+"use strict";
+const whatwgURL = require("whatwg-url-compat");
+const resolveHref = require("../utils").resolveHref;
+
+function StateEntry(data, title, url) {
+  this.data = data;
+  this.title = title;
+  this.url = url;
+}
+
+module.exports = History;
+
+function History(window) {
+  this._states = [new StateEntry(null, "", window._document._URL)];
+  this._index = 0;
+  this._window = window;
+  this._location = window._document._location;
+}
+
+History.prototype = {
+  constructor: History,
+
+  get length() {
+    return this._states.length;
+  },
+
+  get state() {
+    const state = this._states[this._index];
+    return state ? state.data : null;
+  },
+
+  back() {
+    this.go(-1);
+  },
+
+  forward() {
+    this.go(1);
+  },
+
+  go(delta) {
+    if (typeof delta === "undefined" || delta === 0) {
+      this._location.reload();
+      return;
+    }
+
+    const newIndex = this._index + delta;
+
+    if (newIndex < 0 || newIndex >= this.length) {
+      return;
+    }
+
+    this._index = newIndex;
+
+    const state = this._states[newIndex];
+
+    this._applyState(state);
+    this._signalPopstate(state);
+  },
+
+  pushState(data, title, url) {
+    const state = new StateEntry(data, title, url);
+    if (this._index + 1 !== this._states.length) {
+      this._states = this._states.slice(0, this._index + 1);
+    }
+    this._states.push(state);
+    this._applyState(state);
+    this._index++;
+  },
+
+  replaceState(data, title, url) {
+    const state = new StateEntry(data, title, url);
+    this._states[this._index] = state;
+    this._applyState(state);
+  },
+
+  _applyState(state) {
+    whatwgURL.setTheInput(this._location, resolveHref(this._location.href, state.url));
+  },
+
+  _signalPopstate(state) {
+    if (this._window.document) {
+      const ev = this._window.document.createEvent("HTMLEvents");
+      ev.initEvent("popstate", false, false);
+      ev.state = state.data;
+      process.nextTick(() => this._window.dispatchEvent(ev));
+    }
+  },
+
+  toString() {
+    return "[object History]";
+  }
+};

node_modules/jsdom/lib/jsdom/browser/htmltodom.js

@@ -0,0 +1,299 @@
+"use strict";
+
+const parse5 = require("parse5");
+const sax = require("sax");
+const attributes = require("../living/attributes");
+const createDocumentTypeInternal = require("../living/document-type").create;
+const locationInfo = require("../living/helpers/internal-constants").locationInfo;
+
+class HtmlToDom {
+  constructor(core, parser, parsingMode) {
+    if (!parser) {
+      if (parsingMode === "xml") {
+        parser = sax;
+      } else {
+        parser = parse5;
+      }
+    }
+
+    this.core = core;
+    this.parser = parser;
+    this.parsingMode = parsingMode;
+
+    if (parser.DefaultHandler) {
+      this.parserType = "htmlparser2";
+    } else if (parser.Parser && parser.TreeAdapters) {
+      this.parserType = "parse5v1";
+    } else if (parser.moduleName === "HTML5") {
+      this.parserType = "html5";
+    } else if (parser.parser) {
+      this.parserType = "sax";
+    }
+  }
+
+  appendHtmlToElement(html, element) {
+    if (typeof html !== "string") {
+      html = String(html);
+    }
+
+    return this["_parseWith" + this.parserType](html, true, element);
+  }
+
+  appendHtmlToDocument(html, element) {
+    if (typeof html !== "string") {
+      html = String(html);
+    }
+
+    return this["_parseWith" + this.parserType](html, false, element);
+  }
+
+  _parseWithhtmlparser2(html, fragment, element) {
+    const handler = new this.parser.DefaultHandler();
+    // Check if document is XML
+    const isXML = this.parsingMode === "xml";
+    const parserInstance = new this.parser.Parser(handler, {
+      xmlMode: isXML,
+      lowerCaseTags: !isXML,
+      lowerCaseAttributeNames: !isXML,
+      decodeEntities: true
+    });
+
+    parserInstance.includeLocation = false;
+    parserInstance.parseComplete(html);
+
+    const parsed = handler.dom;
+    for (let i = 0; i < parsed.length; i++) {
+      setChild(this.core, element, parsed[i]);
+    }
+
+    return element;
+  }
+
+  _parseWithparse5v1(html, fragment, element) {
+    if (this.parsingMode === "xml") {
+      throw new Error("Can't parse XML with parse5, please use htmlparser2 instead.");
+    }
+
+    const htmlparser2Adapter = this.parser.TreeAdapters.htmlparser2;
+    let dom;
+    if (fragment) {
+      const instance = new this.parser.Parser(htmlparser2Adapter);
+      const parentElement = htmlparser2Adapter.createElement(element.tagName.toLowerCase(), element.namespaceURI, []);
+      dom = instance.parseFragment(html, parentElement);
+    } else {
+      const instance = new this.parser.Parser(htmlparser2Adapter, { locationInfo: true });
+      dom = instance.parse(html);
+    }
+
+    const parsed = dom.children;
+    for (let i = 0; i < parsed.length; i++) {
+      setChild(this.core, element, parsed[i]);
+    }
+
+    return element;
+  }
+
+  _parseWithhtml5(html, fragment, element) {
+    if (element.nodeType === 9) {
+      new this.parser.Parser({ document: element }).parse(html);
+    } else {
+      const p = new this.parser.Parser({ document: element.ownerDocument });
+      p.parse_fragment(html, element);
+    }
+  }
+
+  _parseWithsax(html, fragment, element) {
+    const SaxParser = this.parser.parser;
+    const parser = new SaxParser(false, { xmlns: true });
+    parser.looseCase = "toString";
+    const openStack = [element];
+    parser.ontext = text => {
+      setChild(this.core, openStack[openStack.length - 1], {
+        type: "text",
+        data: text
+      });
+    };
+    parser.onopentag = arg => {
+      const attrValues = {};
+      const attrPrefixes = {};
+      const attrNamespaces = {};
+      Object.keys(arg.attributes).forEach(key => {
+        const localName = arg.attributes[key].local;
+        attrValues[localName] = arg.attributes[key].value;
+        attrPrefixes[localName] = arg.attributes[key].prefix || null;
+        attrNamespaces[localName] = arg.attributes[key].uri || null;
+      });
+
+      if (arg.local === "script" && arg.uri === "http://www.w3.org/1999/xhtml") {
+        openStack.push({
+          type: "tag",
+          name: arg.local,
+          prefix: arg.prefix,
+          namespace: arg.uri,
+          attribs: attrValues,
+          "x-attribsPrefix": attrPrefixes,
+          "x-attribsNamespace": attrNamespaces
+        });
+      } else {
+        const elem = setChild(this.core, openStack[openStack.length - 1], {
+          type: "tag",
+          name: arg.local,
+          prefix: arg.prefix,
+          namespace: arg.uri,
+          attribs: attrValues,
+          "x-attribsPrefix": attrPrefixes,
+          "x-attribsNamespace": attrNamespaces
+        });
+        openStack.push(elem);
+      }
+    };
+    parser.onclosetag = () => {
+      const elem = openStack.pop();
+      if (elem.constructor.name === "Object") { // we have an empty script tag
+        setChild(this.core, openStack[openStack.length - 1], elem);
+      }
+    };
+    parser.onscript = scriptText => {
+      const tag = openStack.pop();
+      tag.children = [{ type: "text", data: scriptText }];
+      const elem = setChild(this.core, openStack[openStack.length - 1], tag);
+      openStack.push(elem);
+    };
+    parser.oncomment = comment => {
+      setChild(this.core, openStack[openStack.length - 1], {
+        type: "comment",
+        data: comment
+      });
+    };
+    parser.onprocessinginstruction = pi => {
+      setChild(this.core, openStack[openStack.length - 1], {
+        type: "directive",
+        name: "?" + pi.name,
+        data: "?" + pi.name + " " + pi.body + "?"
+      });
+    };
+    parser.ondoctype = dt => {
+      setChild(this.core, openStack[openStack.length - 1], {
+        type: "directive",
+        name: "!doctype",
+        data: "!doctype " + dt
+      });
+    };
+    parser.write(html).close();
+  }
+}
+
+// utility function for forgiving parser
+function setChild(core, parent, node) {
+  const currentDocument = parent._ownerDocument || parent;
+
+  let newNode;
+  let isTemplateContents = false;
+  switch (node.type) {
+    case "tag":
+    case "script":
+    case "style":
+      newNode = currentDocument._createElementWithCorrectElementInterface(node.name, node.namespace);
+      newNode._localName = node.name;
+      newNode._prefix = node.prefix || null;
+      newNode._namespaceURI = node.namespace || null;
+      break;
+
+    case "root":
+      // If we are in <template> then add all children to the parent's _templateContents; skip this virtual root node.
+      if (parent.tagName === "TEMPLATE" && parent._namespaceURI === "http://www.w3.org/1999/xhtml") {
+        newNode = parent._templateContents;
+        isTemplateContents = true;
+      }
+      break;
+
+    case "text":
+      // HTML entities should already be decoded by the parser, so no need to decode them
+      newNode = currentDocument.createTextNode(node.data);
+      break;
+
+    case "comment":
+      newNode = currentDocument.createComment(node.data);
+      break;
+
+    case "directive":
+      if (node.name[0] === "?" && node.name.toLowerCase() !== "?xml") {
+        const data = node.data.slice(node.name.length + 1, -1);
+        newNode = currentDocument.createProcessingInstruction(node.name.substring(1), data);
+      } else if (node.name.toLowerCase() === "!doctype") {
+        if (node["x-name"] !== undefined) { // parse5 supports doctypes directly
+          newNode = createDocumentTypeInternal(core, currentDocument,
+            node["x-name"] || "",
+            node["x-publicId"] || "",
+            node["x-systemId"] || "");
+        } else {
+          newNode = parseDocType(core, currentDocument, "<" + node.data + ">");
+        }
+      }
+      break;
+  }
+
+  if (!newNode) {
+    return null;
+  }
+
+  newNode[locationInfo] = node.__location;
+
+  if (node.attribs) {
+    for (let localName in node.attribs) {
+      const value = node.attribs[localName];
+      let prefix = node["x-attribsPrefix"] && node["x-attribsPrefix"][localName] || null;
+      const namespace = node["x-attribsNamespace"] && node["x-attribsNamespace"][localName] || null;
+      if (prefix === "xmlns" && localName === "") {
+         // intended weirdness in node-sax, see https://github.com/isaacs/sax-js/issues/165
+        localName = prefix;
+        prefix = null;
+      }
+      attributes.setAttributeValue(newNode, localName, value, prefix, namespace);
+    }
+  }
+
+  if (node.children) {
+    for (let c = 0; c < node.children.length; c++) {
+      setChild(core, newNode, node.children[c]);
+    }
+  }
+
+  if (!isTemplateContents) {
+    if (parent._templateContents) {
+      // Setting innerHTML on a <template>
+      parent._templateContents.appendChild(newNode);
+    } else {
+      parent.appendChild(newNode);
+    }
+  }
+
+  return newNode;
+}
+
+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;
+
+function parseDocType(core, doc, html) {
+  if (HTML5_DOCTYPE.test(html)) {
+    return createDocumentTypeInternal(core, doc, "html", "", "");
+  }
+
+  const publicPieces = PUBLIC_DOCTYPE.exec(html);
+  if (publicPieces) {
+    return createDocumentTypeInternal(core, doc, publicPieces[1], publicPieces[2], publicPieces[3]);
+  }
+
+  const systemPieces = SYSTEM_DOCTYPE.exec(html);
+  if (systemPieces) {
+    return createDocumentTypeInternal(core, doc, systemPieces[1], "", systemPieces[2]);
+  }
+
+  // Shouldn't get here (the parser shouldn't let us know about invalid doctypes), but our logic likely isn't
+  // real-world perfect, so let's fallback.
+  return createDocumentTypeInternal(core, doc, "html", "", "");
+}
+
+
+exports.HtmlToDom = HtmlToDom;

node_modules/jsdom/lib/jsdom/browser/location.js

@@ -0,0 +1,67 @@
+"use strict";
+const whatwgURL = require("whatwg-url-compat");
+const documentBaseURL = require("../living/helpers/document-base-url").documentBaseURL;
+const notImplemented = require("./not-implemented");
+const URL = whatwgURL.createURLConstructor();
+
+module.exports = Location;
+
+const document = Symbol("relevant document");
+const oldParsedURL = Symbol("old parsed URL");
+
+function Location(urlString, relevantDocument) {
+  this[document] = relevantDocument;
+  whatwgURL.setTheInput(this, urlString);
+
+  try {
+    this[oldParsedURL] = new URL(urlString);
+  } catch (e) {
+    this[oldParsedURL] = {};
+  }
+}
+
+whatwgURL.mixinURLUtils(
+  Location.prototype,
+  function getTheBase() {
+    return documentBaseURL(this[document]);
+  },
+  function updateSteps() {
+    if (this[oldParsedURL].protocol !== this.protocol ||
+        this[oldParsedURL].username !== this.username ||
+        this[oldParsedURL].password !== this.password ||
+        this[oldParsedURL].hostname !== this.hostname ||
+        this[oldParsedURL].port !== this.port ||
+        this[oldParsedURL].pathname !== this.pathname ||
+        this[oldParsedURL].search !== this.search) {
+      notImplemented("navigation via the location interface", this[document]._defaultView);
+    } else if (this[oldParsedURL].hash !== this.hash) {
+      const window = this[document].defaultView;
+      const ev = new window.HashChangeEvent("hashchange", {
+        bubbles: true,
+        cancelable: false,
+        oldURL: this[oldParsedURL].href,
+        newURL: this.href
+      });
+
+      window.setTimeout(() => {
+        window.dispatchEvent(ev);
+      }, 0);
+    }
+
+    this[oldParsedURL] = new URL(this.href);
+    this[document]._URL = this.href;
+  }
+);
+
+Location.prototype.assign = function () {
+  notImplemented("location.assign", this[document]._defaultView);
+};
+
+Location.prototype.replace = function (url) {
+  // This is nowhere near spec compliant, but has worked so far.
+  whatwgURL.setTheInput(this, url);
+};
+
+Location.prototype.reload = function () {
+  notImplemented("location.reload", this[document]._defaultView);
+};

node_modules/jsdom/lib/jsdom/browser/not-implemented.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = function (nameForErrorMessage, window) {
+  if (!window) {
+    // Do nothing for window-less documents.
+    return;
+  }
+
+  window._virtualConsole.emit("jsdomError", new Error(`Not implemented: ${nameForErrorMessage}`));
+};

node_modules/jsdom/lib/jsdom/browser/resource-loader.js

@@ -0,0 +1,220 @@
+"use strict";
+
+const resolveHref = require("../utils").resolveHref;
+const parseDataUrl = require("../utils").parseDataUrl;
+const fs = require("fs");
+const request = require("request");
+const documentBaseURL = require("../living/helpers/document-base-url").documentBaseURL;
+const internalConstants = require("../living/helpers/internal-constants");
+const NODE_TYPE = require("../living/node-type");
+
+/* eslint-disable no-restricted-modules */
+// TODO: stop using the built-in URL in favor of the spec-compliant whatwg-url package
+// This legacy usage is in the process of being purged.
+const URL = require("url");
+/* eslint-enable no-restricted-modules */
+
+const IS_BROWSER = Object.prototype.toString.call(process) !== "[object process]";
+
+function createResourceLoadHandler(element, resourceUrl, document, loadCallback) {
+  return function (err, data) {
+    const ev = document.createEvent("HTMLEvents");
+
+    if (!err) {
+      try {
+        loadCallback.call(element, data, resourceUrl);
+        ev.initEvent("load", false, false);
+      } catch (e) {
+        err = e;
+      }
+    }
+
+    if (err) {
+      ev.initEvent("error", false, false);
+      ev.error = err;
+
+      const error = new Error(`Could not load ${element.localName}: "${resourceUrl}"`);
+      error.detail = err;
+      document._defaultView._virtualConsole.emit("jsdomError", error);
+    }
+
+    element.dispatchEvent(ev);
+  };
+}
+
+exports.readFile = function (filePath, callback) {
+  const readableStream = fs.createReadStream(filePath, { encoding: "utf8" });
+
+  let data = "";
+
+  readableStream.on("error", callback);
+
+  readableStream.on("data", chunk => {
+    data += chunk;
+  });
+
+  readableStream.on("end", () => {
+    callback(null, data);
+  });
+
+  return {
+    abort() {
+      readableStream.destroy();
+      callback(new Error("request canceled by user"));
+    }
+  };
+};
+
+// NOTE: request wraps tough-cookie cookie jar
+// (see: https://github.com/request/request/blob/master/lib/cookies.js).
+// Therefore, to pass our cookie jar to the request, we need to create
+// request's wrapper and monkey patch it with our jar.
+function wrapCookieJarForRequest(cookieJar) {
+  const jarWrapper = request.jar();
+  jarWrapper._jar = cookieJar;
+  return jarWrapper;
+}
+
+function fetch(element, urlObj, cookieJar, referrer, pool, agentOptions, userAgent, callback) {
+  let req = null;
+  if (urlObj.protocol === "data:") {
+    process.nextTick(() => {
+      try {
+        const buffer = parseDataUrl(urlObj.href).buffer;
+        callback(null, buffer.toString());
+      } catch (err) {
+        callback(err, null);
+      }
+    });
+  } else if (urlObj.hostname) {
+    const requestOptions = {
+      pool,
+      agentOptions,
+      headers: {
+        "User-Agent": userAgent
+      }
+    };
+    if (element[internalConstants.accept]) {
+      requestOptions.headers.Accept = element[internalConstants.accept];
+    }
+    req = exports.download(urlObj, requestOptions, cookieJar, referrer, callback);
+  } else {
+    const filePath = urlObj.pathname
+      .replace(/^file:\/\//, "")
+      .replace(/^\/([a-z]):\//i, "$1:/")
+      .replace(/%20/g, " ");
+    req = exports.readFile(filePath, callback);
+  }
+  return req;
+}
+
+exports.enqueue = function (element, resourceUrl, callback) {
+  const document = element.nodeType === NODE_TYPE.DOCUMENT_NODE ? element : element._ownerDocument;
+
+  if (document._queue) {
+    const loadHandler = createResourceLoadHandler(element, resourceUrl || document.URL, document, callback);
+    return document._queue.push(loadHandler);
+  }
+
+  return function () { };
+};
+
+exports.resolveResourceUrl = function (document, url) {
+  // if getAttribute returns null, there is no href
+  // lets resolve to an empty string (nulls are not expected farther up)
+  if (url === null) {
+    return "";
+  }
+
+  const baseUrl = documentBaseURL(document);
+  return resolveHref(baseUrl, url);
+};
+
+
+function objGetter(obj, prop) {
+  const lprop = prop.toLowerCase();
+  for (const p in obj) {
+    if (obj.hasOwnProperty(p) && lprop === p.toLowerCase()) {
+      return obj[p];
+    }
+  }
+  return null;
+}
+
+exports.download = function (url, options, cookieJar, referrer, callback) {
+  options = options || {};
+  options.gzip = true;
+  options.jar = wrapCookieJarForRequest(cookieJar);
+  options.headers = options.headers || {};
+  if (referrer && !IS_BROWSER) {
+    options.headers.referer = referrer;
+  }
+  if (!objGetter(options.headers, "Accept")) {
+    options.headers.Accept = "*/*";
+  }
+  if (!objGetter(options.headers, "Accept-Language")) {
+    options.headers["Accept-Language"] = "en";
+  }
+
+  const req = request(url, options, (error, response, data) => callback(error, data, response));
+  return {
+    abort() {
+      req.abort();
+      callback(new Error("request canceled by user"));
+    }
+  };
+};
+
+exports.load = function (element, url, callback) {
+  const document = element._ownerDocument;
+  const documentImpl = document.implementation;
+
+  if (!documentImpl._hasFeature("FetchExternalResources", element.tagName.toLowerCase())) {
+    return;
+  }
+
+  // if getAttribute returns null, there is no href
+  // lets resolve to an empty string (nulls are not expected farther up)
+  const resourceUrl = exports.resolveResourceUrl(document, url);
+
+  if (documentImpl._hasFeature("SkipExternalResources", resourceUrl)) {
+    return;
+  }
+
+  const urlObj = URL.parse(resourceUrl);
+  const baseUrl = documentBaseURL(document);
+  const cookieJar = document._cookieJar;
+  const enqueued = exports.enqueue(element, resourceUrl, callback);
+  const customLoader = document._customResourceLoader;
+  const requestManager = document[internalConstants.requestManager];
+  const pool = document[internalConstants.pool];
+  const agentOptions = document[internalConstants.agentOptions];
+  const userAgent = document._defaultView.navigator.userAgent;
+  let req = null;
+  function wrappedEnqueued() {
+    if (req && requestManager) {
+      requestManager.remove(req);
+    }
+    // do not trigger if the window is closed
+    if (element._ownerDocument && element._ownerDocument.defaultView.document) {
+      enqueued.apply(this, arguments);
+    }
+  }
+  if (typeof customLoader === "function") {
+    req = customLoader({
+      element,
+      url: urlObj,
+      cookie: cookieJar.getCookieStringSync(urlObj, { http: true }),
+      baseUrl,
+      defaultFetch(fetchCallback) {
+        return fetch(element, urlObj, cookieJar, baseUrl, pool, agentOptions, userAgent, fetchCallback);
+      }
+    },
+    wrappedEnqueued);
+  } else {
+    req = fetch(element, urlObj, cookieJar, baseUrl, pool, agentOptions, userAgent, wrappedEnqueued);
+  }
+  if (req && requestManager) {
+    requestManager.add(req);
+  }
+};

node_modules/jsdom/lib/jsdom/level1/core.js

@@ -0,0 +1,988 @@
+"use strict";
+/*
+  ServerJS Javascript DOM Level 1
+*/
+var inheritFrom = require("../utils").inheritFrom;
+var domToHtml = require("../browser/domtohtml").domToHtml;
+var defineGetter = require("../utils").defineGetter;
+var memoizeQuery = require("../utils").memoizeQuery;
+var validateName = require('../living/helpers/validate-names').name;
+var HtmlToDom = require("../browser/htmltodom").HtmlToDom;
+var Location = require("../browser/location");
+var vm = require("vm");
+var CookieJar = require('tough-cookie').CookieJar;
+var EventTarget = require("../living/generated/EventTarget");
+var attributes = require("../living/attributes");
+var mapper = require("../utils").mapper;
+var clone = require("../living/node").clone;
+var namedPropertiesWindow = require("../living/named-properties-window");
+var Window = require('../browser/Window');
+var proxiedWindowEventHandlers = require("../living/helpers/proxied-window-event-handlers");
+const URL = require("../utils").URL;
+const domSymbolTree = require("../living/helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("../living/node-type");
+const resetDOMTokenList = require("../living/dom-token-list").reset;
+const createLiveNodeList = require("../living/node-list").createLive;
+const updateNodeList = require("../living/node-list").update;
+const updateHTMLCollection = require("../living/html-collection").update;
+
+// utility functions
+var attachId = function(id,elm,doc) {
+  if (id && elm && doc) {
+    if (!doc._ids[id]) {
+      doc._ids[id] = [];
+    }
+    doc._ids[id].push(elm);
+  }
+};
+var detachId = function(id,elm,doc) {
+  var elms, i;
+  if (id && elm && doc) {
+    if (doc._ids && doc._ids[id]) {
+      elms = doc._ids[id];
+      for (i=0;i<elms.length;i++) {
+        if (elms[i] === elm) {
+          elms.splice(i,1);
+          i--;
+        }
+      }
+      if (elms.length === 0) {
+        delete doc._ids[id];
+      }
+    }
+  }
+};
+
+function setInnerHTML(document, node, html) {
+  // Clear the children first:
+  if (node._templateContents) {
+    clearChildNodes(node._templateContents);
+  } else {
+    clearChildNodes(node);
+  }
+
+  if (html !== "") {
+    if (node.nodeName === "#document") {
+      document._htmlToDom.appendHtmlToDocument(html, node);
+    } else {
+      document._htmlToDom.appendHtmlToElement(html, node);
+    }
+  }
+}
+
+function clearChildNodes(node) {
+  for (let child = null; child = domSymbolTree.firstChild(node);) {
+    node.removeChild(child);
+  }
+}
+
+var core = exports;
+
+core.DOMException = require("../web-idl/DOMException");
+core.NamedNodeMap = require("../living/attributes").NamedNodeMap;
+
+core.DOMImplementation = function DOMImplementation(document, /* Object */ features) {
+  throw new TypeError("Illegal constructor");
+};
+
+core.DOMImplementation.prototype = {
+  // All of these are legacy, left because jsdom uses them internally :(. jsdom confused the idea of browser features
+  // and jsdom features
+  _removeFeature : function(feature, version) {
+    feature = feature.toLowerCase();
+    if (this._features[feature]) {
+      if (version) {
+        var j        = 0,
+            versions = this._features[feature],
+            l        = versions.length;
+
+        for (j; j<l; j++) {
+          if (versions[j] === version) {
+            versions.splice(j,1);
+            return;
+          }
+        }
+      } else {
+        delete this._features[feature];
+      }
+    }
+  },
+
+  _addFeature: function(feature, version) {
+    feature = feature.toLowerCase();
+
+    if (version) {
+
+      if (!this._features[feature]) {
+        this._features[feature] = [];
+      }
+
+      if (version instanceof Array) {
+        Array.prototype.push.apply(this._features[feature], version);
+      } else {
+        this._features[feature].push(version);
+      }
+
+      if (feature === "processexternalresources" &&
+          (version === "script" || (version.indexOf && version.indexOf("script") !== -1)) &&
+          !vm.isContext(this._ownerDocument._global)) {
+        vm.createContext(this._ownerDocument._global);
+        this._ownerDocument._defaultView._globalProxy = vm.runInContext("this", this._ownerDocument._global);
+        this._ownerDocument._defaultView = this._ownerDocument._defaultView._globalProxy;
+      }
+    }
+  },
+
+  // The real hasFeature is in living/dom-implementation.js, and returns true always.
+  // This one is used internally
+  _hasFeature: function(/* string */ feature, /* string */ version) {
+    feature = (feature) ? feature.toLowerCase() : '';
+    var versions = (this._features[feature]) ?
+                    this._features[feature]  :
+                    false;
+
+    if (!version && versions.length && versions.length > 0) {
+      return true;
+    } else if (typeof versions === 'string') {
+      return versions === version;
+    } else if (versions.indexOf && versions.length > 0) {
+      for (var i = 0; i < versions.length; i++) {
+        var found = versions[i] instanceof RegExp ?
+          versions[i].test(version) :
+          versions[i] === version;
+        if (found) { return true; }
+      }
+      return false;
+    } else {
+      return false;
+    }
+  }
+};
+
+core.Node = function Node(ownerDocument) {
+  EventTarget.setup(this);
+
+  domSymbolTree.initialize(this);
+  this._childNodesList = null;
+  this._ownerDocument = ownerDocument;
+  this._childrenList = null;
+  this._version = 0;
+  this._memoizedQueries = {};
+  this._readonly = false;
+};
+
+core.Node.ELEMENT_NODE                = NODE_TYPE.ELEMENT_NODE;
+core.Node.ATTRIBUTE_NODE              = NODE_TYPE.ATTRIBUTE_NODE;
+core.Node.TEXT_NODE                   = NODE_TYPE.TEXT_NODE;
+core.Node.CDATA_SECTION_NODE          = NODE_TYPE.CDATA_SECTION_NODE;
+core.Node.ENTITY_REFERENCE_NODE       = NODE_TYPE.ENTITY_REFERENCE_NODE;
+core.Node.ENTITY_NODE                 = NODE_TYPE.ENTITY_NODE;
+core.Node.PROCESSING_INSTRUCTION_NODE = NODE_TYPE.PROCESSING_INSTRUCTION_NODE;
+core.Node.COMMENT_NODE                = NODE_TYPE.COMMENT_NODE;
+core.Node.DOCUMENT_NODE               = NODE_TYPE.DOCUMENT_NODE;
+core.Node.DOCUMENT_TYPE_NODE          = NODE_TYPE.DOCUMENT_TYPE_NODE;
+core.Node.DOCUMENT_FRAGMENT_NODE      = NODE_TYPE.DOCUMENT_FRAGMENT_NODE;
+core.Node.NOTATION_NODE               = NODE_TYPE.NOTATION_NODE;
+
+core.Node.prototype = {
+  ELEMENT_NODE                : NODE_TYPE.ELEMENT_NODE,
+  ATTRIBUTE_NODE              : NODE_TYPE.ATTRIBUTE_NODE,
+  TEXT_NODE                   : NODE_TYPE.TEXT_NODE,
+  CDATA_SECTION_NODE          : NODE_TYPE.CDATA_SECTION_NODE,
+  ENTITY_REFERENCE_NODE       : NODE_TYPE.ENTITY_REFERENCE_NODE,
+  ENTITY_NODE                 : NODE_TYPE.ENTITY_NODE,
+  PROCESSING_INSTRUCTION_NODE : NODE_TYPE.PROCESSING_INSTRUCTION_NODE,
+  COMMENT_NODE                : NODE_TYPE.COMMENT_NODE,
+  DOCUMENT_NODE               : NODE_TYPE.DOCUMENT_NODE,
+  DOCUMENT_TYPE_NODE          : NODE_TYPE.DOCUMENT_TYPE_NODE,
+  DOCUMENT_FRAGMENT_NODE      : NODE_TYPE.DOCUMENT_FRAGMENT_NODE,
+  NOTATION_NODE               : NODE_TYPE.NOTATION_NODE,
+
+  get nodeValue() {
+    if (this.nodeType === NODE_TYPE.TEXT_NODE ||
+        this.nodeType === NODE_TYPE.COMMENT_NODE ||
+        this.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE) {
+      return this._data;
+    }
+
+    return null;
+  },
+  set nodeValue(value) {
+    if (this.nodeType === NODE_TYPE.TEXT_NODE ||
+        this.nodeType === NODE_TYPE.COMMENT_NODE ||
+        this.nodeType === NODE_TYPE.PROCESSING_INSTRUCTION_NODE) {
+      this.replaceData(0, this.length, value);
+    }
+  },
+  get parentNode() {
+    return domSymbolTree.parent(this);
+  },
+
+  get nodeName() {
+    switch (this.nodeType) {
+      case NODE_TYPE.ELEMENT_NODE:
+        return this.tagName;
+      case NODE_TYPE.TEXT_NODE:
+        return "#text";
+      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";
+    }
+  },
+  set nodeName(unused) { throw new core.DOMException();},
+  get firstChild() {
+    return domSymbolTree.firstChild(this);
+  },
+  get ownerDocument() {
+    // TODO: when we move nodeType to Node.prototype and add an internal _nodeType, consult that instead.
+    return this.nodeType === NODE_TYPE.DOCUMENT_NODE ? null : this._ownerDocument;
+  },
+  get readonly() { return this._readonly;},
+
+  get lastChild() {
+    return domSymbolTree.lastChild(this);
+  },
+
+  get childNodes() {
+    if (!this._childNodesList) {
+      var self = this;
+      this._childNodesList = createLiveNodeList(this, function() {
+        return domSymbolTree.childrenToArray(self);
+      });
+    } else {
+      updateNodeList(this._childNodesList);
+    }
+
+    return this._childNodesList;
+  },
+  set childNodes(unused) { throw new core.DOMException();},
+
+  get nextSibling() {
+    return domSymbolTree.nextSibling(this);
+  },
+  set nextSibling(unused) { throw new core.DOMException();},
+
+  get previousSibling() {
+    return domSymbolTree.previousSibling(this);
+  },
+  set previousSibling(unused) { throw new core.DOMException();},
+
+  /* returns Node */
+  insertBefore :  function(/* Node */ newChild, /* Node*/ refChild) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Node.prototype.insertBefore");
+    }
+    if (refChild === undefined) {
+      refChild = null;
+    }
+
+    // TODO branding
+    if (!newChild || !("nodeType" in newChild)) {
+      throw new TypeError("First argument to Node.prototype.insertBefore must be a Node");
+    }
+    if (refChild !== null && !("nodeType" in refChild)) {
+      throw new TypeError("Second argument to Node.prototype.insertBefore must be a Node or null or undefined");
+    }
+
+    if (this._readonly === true) {
+      throw new core.DOMException(core.DOMException.NO_MODIFICATION_ALLOWED_ERR, 'Attempting to modify a read-only node');
+    }
+
+    // DocumentType must be implicitly adopted
+    if (newChild.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) newChild._ownerDocument = this._ownerDocument;
+
+    // TODO - if (!newChild) then?
+    if (!(this instanceof core.Document) && newChild._ownerDocument !== this._ownerDocument) {
+      throw new core.DOMException(core.DOMException.WRONG_DOCUMENT_ERR);
+    }
+
+    if (newChild.nodeType && newChild.nodeType === NODE_TYPE.ATTRIBUTE_NODE) {
+      throw new core.DOMException(core.DOMException.HIERARCHY_REQUEST_ERR);
+    }
+
+    // search for parents matching the newChild
+    for (const ancestor of domSymbolTree.ancestorsIterator(this)) {
+      if (ancestor === newChild) {
+        throw new core.DOMException(core.DOMException.HIERARCHY_REQUEST_ERR);
+      }
+    }
+
+    // fragments are merged into the element (except parser-created fragments in <template>)
+    if (newChild.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE) {
+
+      let grandChild;
+      while ((grandChild = domSymbolTree.firstChild(newChild))) {
+        newChild.removeChild(grandChild);
+        this.insertBefore(grandChild, refChild);
+      }
+
+    } else if (newChild === refChild) {
+      return newChild;
+    } else {
+      const oldParent = domSymbolTree.parent(newChild);
+      // if the newChild is already in the tree elsewhere, remove it first
+      if (oldParent) {
+        oldParent.removeChild(newChild);
+      }
+
+      if (refChild == null) {
+        domSymbolTree.appendChild(this, newChild);
+      } else {
+        if (domSymbolTree.parent(refChild) !== this) {
+          throw new core.DOMException(core.DOMException.NOT_FOUND_ERR);
+        }
+
+        domSymbolTree.insertBefore(refChild, newChild);
+      }
+
+      this._modified();
+
+      if (this._attached && newChild._attach) {
+        newChild._attach();
+      }
+
+      this._descendantAdded(this, newChild);
+    }
+
+    return newChild;
+  }, // raises(DOMException);
+
+  _modified: function() {
+    this._version++;
+    if (this._ownerDocument) {
+      this._ownerDocument._version++;
+    }
+
+    if (this._childrenList) {
+      updateHTMLCollection(this._childrenList);
+    }
+    if (this._childNodesList) {
+      updateNodeList(this._childNodesList);
+    }
+    this._clearMemoizedQueries();
+  },
+
+  _clearMemoizedQueries: function() {
+    this._memoizedQueries = {};
+    const myParent = domSymbolTree.parent(this);
+    if (myParent) {
+      myParent._clearMemoizedQueries();
+    }
+  },
+
+  _descendantRemoved: function(parent, child) {
+    const myParent = domSymbolTree.parent(this);
+    if (myParent) {
+      myParent._descendantRemoved(parent, child);
+    }
+  },
+
+  _descendantAdded: function(parent, child) {
+    const myParent = domSymbolTree.parent(this);
+    if (myParent) {
+      myParent._descendantAdded(parent, child);
+    }
+  },
+
+  _attrModified: function(name, value, oldValue) {
+    this._modified();
+    namedPropertiesWindow.elementAttributeModified(this, name, value, oldValue);
+
+    if (name == 'id' && this._attached) {
+      var doc = this._ownerDocument;
+      detachId(oldValue,this,doc);
+      attachId(value,this,doc);
+    }
+
+    // TODO event handlers:
+    // The correct way to do this is lazy, and a bit more complicated; see
+    // https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-content-attributes
+    // It would only be possible if we had proper getters/setters for every event handler, which we don't right now.
+    if (name.length > 2 && name[0] === 'o' && name[1] === 'n') {
+      if (value) {
+        var w = this._ownerDocument._global;
+        var self = proxiedWindowEventHandlers.has(name) && this._localName === 'body' ? w : this;
+        var vmOptions = { filename: this._ownerDocument._URL, displayErrors: false };
+
+        // The handler code probably refers to functions declared globally on the window, so we need to run it in
+        // that context. In fact, it's worse; see
+        // https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/bindings/core/v8/V8LazyEventListener.cpp
+        // plus the spec, which show how multiple nested scopes are technically required. We won't implement that
+        // until someone asks for it, though.
+
+        // https://html.spec.whatwg.org/multipage/webappapis.html#the-event-handler-processing-algorithm
+
+        if (name === "onerror" && self === w) {
+          // https://html.spec.whatwg.org/multipage/webappapis.html#getting-the-current-value-of-the-event-handler
+          // step 10
+
+          self[name] = function (event, source, lineno, colno, error) {
+            w.__tempEventHandlerThis = this;
+            w.__tempEventHandlerEvent = event;
+            w.__tempEventHandlerSource = source;
+            w.__tempEventHandlerLineno = lineno;
+            w.__tempEventHandlerColno = colno;
+            w.__tempEventHandlerError = error;
+
+            try {
+              return vm.runInContext(`
+                (function (event, source, lineno, colno, error) {
+                  ${value}
+                }).call(__tempEventHandlerThis, __tempEventHandlerEvent, __tempEventHandlerSource,
+                        __tempEventHandlerLineno, __tempEventHandlerColno, __tempEventHandlerError)`, w, vmOptions);
+            } finally {
+              delete w.__tempEventHandlerThis;
+              delete w.__tempEventHandlerEvent;
+              delete w.__tempEventHandlerSource;
+              delete w.__tempEventHandlerLineno;
+              delete w.__tempEventHandlerColno;
+              delete w.__tempEventHandlerError;
+            }
+          };
+        } else {
+          self[name] = function (event) {
+            w.__tempEventHandlerThis = this;
+            w.__tempEventHandlerEvent = event;
+
+            try {
+              return vm.runInContext(`
+                (function (event) {
+                  ${value}
+                }).call(__tempEventHandlerThis, __tempEventHandlerEvent)`, w, vmOptions);
+            } finally {
+              delete w.__tempEventHandlerThis;
+              delete w.__tempEventHandlerEvent;
+            }
+          };
+        }
+      } else {
+        this[name] = null;
+      }
+    }
+
+    // TODO remove MutationEvents completely at some point
+    if (value !== oldValue && this._ownerDocument &&
+        this._ownerDocument.implementation._hasFeature('MutationEvents')) {
+      var ev = this._ownerDocument.createEvent("MutationEvents");
+
+      var attrChange = core.MutationEvent.MODIFICATION;
+      if (value === null) {
+        attrChange = core.MutationEvent.REMOVAL;
+      }
+      if (oldValue === null) {
+        attrChange = core.MutationEvent.ADDITION;
+      }
+
+      ev.initMutationEvent("DOMAttrModified", true, false, this, oldValue, value, name, attrChange);
+      this.dispatchEvent(ev);
+    }
+
+    // update classList
+    if (name === "class" && value !== this.classList.toString()) {
+      resetDOMTokenList(this.classList, value);
+    }
+  },
+
+  replaceChild(node, child) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Node.prototype.replaceChild");
+    }
+    // TODO branding
+    if (!node || !("nodeType" in node)) {
+      throw new TypeError("First argument to Node.prototype.replaceChild must be a Node");
+    }
+    if (!child || !("nodeType" in child)) {
+      throw new TypeError("Second argument to Node.prototype.replaceChild must be a Node");
+    }
+
+    this.insertBefore(node, child);
+    return this.removeChild(child);
+  },
+
+  /* returns void */
+  _attach : function() {
+    this._attached = true;
+    namedPropertiesWindow.nodeAttachedToDocument(this);
+
+    if (this.id) {
+      attachId(this.id,this,this._ownerDocument);
+    }
+
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child._attach) {
+        child._attach();
+      }
+    }
+  },
+  /* returns void */
+  _detach : function() {
+    this._attached = false;
+
+    namedPropertiesWindow.nodeDetachedFromDocument(this);
+
+    if (this.id) {
+      detachId(this.id,this,this._ownerDocument);
+    }
+
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child._detach) {
+        child._detach();
+      }
+    }
+  },
+
+  /* returns Node */
+  removeChild : function(/* Node */ oldChild){
+    if (this._readonly === true) {
+      throw new core.DOMException(core.DOMException.NO_MODIFICATION_ALLOWED_ERR);
+    }
+
+    if (!oldChild || domSymbolTree.parent(oldChild) !== this) {
+      throw new core.DOMException(core.DOMException.NOT_FOUND_ERR);
+    }
+
+    var oldPreviousSibling = oldChild.previousSibling;
+    domSymbolTree.remove(oldChild);
+    this._modified();
+    oldChild._detach();
+    this._descendantRemoved(this, oldChild);
+    if (this._ownerDocument) {
+      this._ownerDocument._runRemovingSteps(oldChild, this, oldPreviousSibling);
+    }
+    return oldChild;
+  }, // raises(DOMException);
+
+  /* returns Node */
+  appendChild : function(/* Node */ newChild) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Node.prototype.appendChild");
+    }
+    // TODO branding
+    if (!("nodeType" in newChild)) {
+      throw new TypeError("First argument to Node.prototype.appendChild must be a Node");
+    }
+
+    return this.insertBefore(newChild, null);
+  }, // raises(DOMException);
+
+  /* returns boolean */
+  hasChildNodes : function() {
+    return domSymbolTree.hasChildren(this);
+  },
+
+  /* returns void */
+  normalize: function() {
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child.normalize) {
+        child.normalize();
+      }
+
+      // Level2/core clean off empty nodes
+      if (child.nodeValue === "") {
+        this.removeChild(child);
+        continue;
+      }
+
+      const prevChild = domSymbolTree.previousSibling(child);
+
+      if (prevChild &&
+          prevChild.nodeType === NODE_TYPE.TEXT_NODE &&
+          child.nodeType === NODE_TYPE.TEXT_NODE) {
+        // merge text nodes
+        prevChild.appendData(child.nodeValue);
+        this.removeChild(child);
+      }
+    }
+  },
+  toString: function() {
+    var id = '';
+    if (this.id) {
+        id = '#' + this.id;
+    }
+    if (this.className) {
+        var classes = this.className.split(/\s+/);
+        for (var i = 0, len = classes.length; i < len; i++) {
+            id += '.' + classes[i];
+        }
+    }
+    return '[ ' + this.tagName + id + ' ]';
+  }
+};
+
+core.Element = function Element(document, localName) {
+  core.Node.call(this, document);
+  this._namespaceURI = null;
+  this._prefix = null;
+  this._localName = localName;
+  this._attributes = attributes.createNamedNodeMap(this);
+};
+
+inheritFrom(core.Node, core.Element, {
+  get namespaceURI() {
+    return this._namespaceURI;
+  },
+  get prefix() {
+    return this._prefix;
+  },
+  get localName() {
+    return this._localName;
+  },
+  get tagName() {
+    var qualifiedName = this._prefix !== null ? this._prefix + ":" + this._localName : this._localName;
+    if (this.namespaceURI === "http://www.w3.org/1999/xhtml" && this._ownerDocument._parsingMode === "html") {
+      qualifiedName = qualifiedName.toUpperCase();
+    }
+    return qualifiedName;
+  },
+
+  get id() {
+    var idAttr = this.getAttribute("id");
+    if (idAttr === null) {
+      return "";
+    }
+    return idAttr;
+  },
+
+  nodeType : NODE_TYPE.ELEMENT_NODE,
+  get attributes() {
+    return this._attributes;
+  },
+
+  get sourceIndex() {
+    /*
+    * According to QuirksMode:
+    * Get the sourceIndex of element x. This is also the index number for
+    * the element in the document.getElementsByTagName('*') array.
+    * http://www.quirksmode.org/dom/w3c_core.html#t77
+    */
+    var items = this.ownerDocument.getElementsByTagName('*'),
+        len = items.length;
+
+    for (var i = 0; i < len; i++) {
+      if (items[i] === this) {
+        return i;
+      }
+    }
+  },
+
+  get outerHTML() {
+    return domToHtml([this]);
+  },
+
+  set outerHTML(html) {
+    if (html === null) {
+      html = "";
+    }
+
+    var parent = domSymbolTree.parent(this);
+    var document = this._ownerDocument;
+
+    if (!parent) {
+      return;
+    }
+
+    var contextElement;
+    if (parent.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+      throw new core.DOMException(core.DOMException.NO_MODIFICATION_ALLOWED_ERR,
+                                  "Modifications are not allowed for this document");
+    } else if (parent.nodeType === NODE_TYPE.DOCUMENT_FRAGMENT_NODE) {
+      contextElement = document.createElementNS("http://www.w3.org/1999/xhtml", "body");
+    } else if (parent.nodeType === NODE_TYPE.ELEMENT_NODE) {
+      contextElement = clone(core, parent, undefined, false);
+    } else {
+      throw new TypeError("This should never happen");
+    }
+
+    document._htmlToDom.appendHtmlToElement(html, contextElement);
+
+    while (contextElement.firstChild) {
+      parent.insertBefore(contextElement.firstChild, this);
+    }
+
+    parent.removeChild(this);
+  },
+
+  get innerHTML() {
+    var tagName = this.tagName;
+    if (tagName === 'SCRIPT' || tagName === 'STYLE') {
+      var type = this.getAttribute('type');
+      if (!type || /^text\//i.test(type) || /\/javascript$/i.test(type)) {
+        return domToHtml(domSymbolTree.childrenIterator(this));
+      }
+    }
+
+    // In case of <template> we should pass its "template contents" fragment as a serialization root if we have one
+    if (this._templateContents) {
+      return domToHtml(domSymbolTree.childrenIterator(this._templateContents));
+    }
+
+    return domToHtml(domSymbolTree.childrenIterator(this));
+  },
+
+  set innerHTML(html) {
+    if (html === null) {
+      html = "";
+    }
+
+    setInnerHTML(this.ownerDocument, this, html);
+  },
+
+  scrollTop: 0,
+  scrollLeft: 0,
+
+  /* returns NodeList */
+  getElementsByTagName: memoizeQuery(function(/* string */ name) {
+    name = name.toLowerCase();
+
+    function filterByTagName(child) {
+      if (child.nodeName && child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return name === "*" || (child.nodeName.toLowerCase() === name);
+      }
+
+      return false;
+    }
+    return createLiveNodeList(this._ownerDocument || this, mapper(this, filterByTagName, true));
+  }),
+});
+
+core.DocumentFragment = function DocumentFragment(document) {
+  core.Node.call(this, document);
+};
+inheritFrom(core.Node, core.DocumentFragment, {
+  nodeType : NODE_TYPE.DOCUMENT_FRAGMENT_NODE
+});
+
+core.Document = function Document(options) {
+  if (!options || !options.parsingMode || (options.parsingMode !== "html" && options.parsingMode !== "xml")) {
+    throw new Error("options must exist and contain a parsingMode of html or xml");
+  }
+
+  core.Node.call(this, this);
+  this._parsingMode = options.parsingMode;
+  this._htmlToDom = new HtmlToDom(core, options.parser, options.parsingMode);
+
+  this._implementation = Object.create(core.DOMImplementation.prototype);
+  this._implementation._ownerDocument = this;
+  this._implementation._features = {};
+
+  this._defaultView = options.defaultView || null;
+  this._global = options.global;
+  this._documentElement = null;
+  this._ids = Object.create(null);
+  this._attached = true;
+  this._readonly = false;
+  this._currentScript = null;
+  this._cookieJar = options.cookieJar === undefined ? new CookieJar(null, { looseMode: true }) : options.cookieJar;
+
+  this._contentType = options.contentType;
+  if (this._contentType === undefined) {
+    this._contentType = this._parsingMode === "xml" ? "application/xml" : "text/html";
+  }
+
+  this._URL = options.url === undefined ? "about:blank" : new URL(options.url).href;
+  this._location = new Location(this._URL, this);
+
+  if (options.cookie) {
+    var cookies = Array.isArray(options.cookie) ? options.cookie: [options.cookie];
+    var document = this;
+
+    cookies.forEach(function(cookieStr) {
+      document._cookieJar.setCookieSync(cookieStr, document._URL, { ignoreError : true });
+    });
+  }
+
+  this._activeNodeIterators = [];
+  this._activeNodeIteratorsMax = options.concurrentNodeIterators === undefined ?
+                                 10 :
+                                 Number(options.concurrentNodeIterators);
+
+  if (isNaN(this._activeNodeIteratorsMax)) {
+    throw new TypeError("The 'concurrentNodeIterators' option must be a Number");
+  }
+
+  if (this._activeNodeIteratorsMax < 0) {
+    throw new RangeError("The 'concurrentNodeIterators' option must be a non negative Number");
+  }
+};
+
+core.Document._removingSteps = [];
+
+var tagRegEx = /[^\w:\d_\.-]+/i;
+var entRegEx = /[^\w\d_\-&;]+/;
+var invalidAttrRegEx = /[\s"'>/=\u0000-\u001A]/;
+
+inheritFrom(core.Node, core.Document, {
+  nodeType : NODE_TYPE.DOCUMENT_NODE,
+  _elementBuilders : { },
+  _defaultElementBuilder: function(document, tagName) {
+    return new core.Element(document, tagName);
+  },
+  get contentType() { return this._contentType;},
+  get compatMode() { return (this._parsingMode === "xml" || this.doctype) ? "CSS1Compat" : "BackCompat"; },
+  get charset() { return "UTF-8"; },
+  get characterSet() { return "UTF-8"; },
+  get inputEncoding() { return "UTF-8"; },
+  get doctype() {
+    for (const childNode of domSymbolTree.childrenIterator(this)) {
+      if (childNode.nodeType === NODE_TYPE.DOCUMENT_TYPE_NODE) {
+        return childNode;
+      }
+    }
+    return null;
+  },
+  get URL() {
+    return this._URL;
+  },
+  get documentURI() {
+    return this._URL;
+  },
+  get location() {
+    return this._defaultView ? this._location : null;
+  },
+  get documentElement() {
+    if (this._documentElement) {
+      return this._documentElement;
+    }
+
+    for (const childNode of domSymbolTree.childrenIterator(this)) {
+      if (childNode.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        this._documentElement = childNode;
+        return childNode;
+      }
+    }
+
+    return null;
+
+  },
+
+  get implementation() { return this._implementation;},
+  set implementation(implementation) { this._implementation = implementation;},
+  get readonly() { return this._readonly;},
+
+  get defaultView() {
+    return this._defaultView;
+  },
+
+  get currentScript() {
+    return this._currentScript;
+  },
+
+  toString: function () {
+    return '[object HTMLDocument]';
+  },
+
+  _createElementWithCorrectElementInterface: function (name, namespace) {
+    // https://dom.spec.whatwg.org/#concept-element-interface
+    // TODO: eventually we should re-write the element-builder system to be namespace aware, but for now it is not.
+    return (this._elementBuilders[name.toLowerCase()] || this._defaultElementBuilder)(this, name, namespace);
+  },
+
+  appendChild : function(/* Node */ arg) {
+    if (this.documentElement && arg.nodeType == NODE_TYPE.ELEMENT_NODE) {
+      throw new core.DOMException(core.DOMException.HIERARCHY_REQUEST_ERR);
+    }
+    return core.Node.prototype.appendChild.call(this, arg);
+  },
+
+  removeChild : function(/* Node */ arg) {
+    var ret = core.Node.prototype.removeChild.call(this, arg);
+    if (arg == this._documentElement) {
+      this._documentElement = null;// force a recalculation
+    }
+    return ret;
+  },
+
+  _descendantRemoved: function(parent, child) {
+    if (child.tagName === 'STYLE') {
+      var index = this.styleSheets.indexOf(child.sheet);
+      if (index > -1) {
+        this.styleSheets.splice(index, 1);
+      }
+    }
+  },
+
+  /* returns NodeList */
+  getElementsByTagName: memoizeQuery(function(/* string */ name) {
+    function filterByTagName(child) {
+      if (child.nodeName && child.nodeType === NODE_TYPE.ELEMENT_NODE)
+      {
+        if (name === "*") {
+          return true;
+
+        // case insensitivity for html
+        } else if (child._ownerDocument && child._ownerDocument._doctype &&
+                   //child._ownerDocument._doctype.name === "html" &&
+                   child.nodeName.toLowerCase() === name.toLowerCase())
+        {
+          return true;
+        } else if (child.nodeName.toLowerCase() === name.toLowerCase()) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return createLiveNodeList(this.documentElement || this, mapper(this, filterByTagName, true));
+  }),
+
+  write: function () {
+    var text = "";
+    for (var i = 0; i < arguments.length; ++i) {
+      text += String(arguments[i]);
+    }
+
+    if (this._parsingMode === "xml") {
+      throw new core.DOMException(core.DOMException.INVALID_STATE_ERR, "Cannot use document.write on XML documents");
+    }
+
+    if (this._writeAfterElement) {
+      // If called from an script element directly (during the first tick),
+      // the new elements are inserted right after that element.
+      var tempDiv = this.createElement('div');
+      setInnerHTML(this, tempDiv, text);
+
+      var child = tempDiv.firstChild;
+      var previous = this._writeAfterElement;
+      var parent = this._writeAfterElement.parentNode;
+
+      while (child) {
+        var node = child;
+        child = child.nextSibling;
+        parent.insertBefore(node, previous.nextSibling);
+        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.
+      var node = this;
+      while (node.lastChild && node.lastChild.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        node = node.lastChild;
+      }
+      setInnerHTML(this, node, text);
+    } else if (text) {
+      setInnerHTML(this, this, text);
+    }
+  },
+
+  writeln: function () {
+    const args = [];
+    for (let i = 0; i < arguments.length; ++i) {
+      args.push(arguments[i]);
+    }
+    args.push("\n");
+    this.write.apply(this, args);
+  },
+
+  _runRemovingSteps: function(oldNode, oldParent, oldPreviousSibling) {
+    var listeners = core.Document._removingSteps;
+    for (var i = 0; i < listeners.length; ++i) {
+      listeners[i](this, oldNode, oldParent, oldPreviousSibling);
+    }
+  }
+});

node_modules/jsdom/lib/jsdom/level2/core.js

@@ -0,0 +1,39 @@
+var core         = require("../level1/core");
+var memoizeQuery = require('../utils').memoizeQuery;
+var validateAndExtract = require('../living/helpers/validate-names').validateAndExtract;
+var mapper = require("../utils").mapper;
+const createLiveNodeList = require("../living/node-list").createLive;
+const NODE_TYPE = require("../living/node-type");
+
+core.Element.prototype.getElementsByTagNameNS = memoizeQuery(function(/* String */ namespaceURI,
+                                                         /* String */ localName)
+{
+  function filterByTagName(child) {
+    var localMatch = child.localName === localName,
+        nsMatch    = child.namespaceURI === namespaceURI;
+
+    if ((localMatch || localName === "*") &&
+        (nsMatch || namespaceURI === "*"))
+    {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  return createLiveNodeList(this.ownerDocument || this, mapper(this, filterByTagName));
+});
+
+core.Document.prototype.getElementsByTagNameNS = function(/* String */ namespaceURI,
+                                                          /* String */ localName)
+{
+  return core.Element.prototype.getElementsByTagNameNS.call(this,
+                                                            namespaceURI,
+                                                            localName);
+};
+
+core.Document.prototype.getElementById = function(id) {
+  // return the first element
+  return (this._ids && this._ids[id] && this._ids[id].length > 0 ? this._ids[id][0] : null);
+};

node_modules/jsdom/lib/jsdom/level2/events.js

@@ -0,0 +1,157 @@
+"use strict";
+/* DOM Level2 Events implemented as described here:
+ *
+ * http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html
+ *
+ */
+var core = require("../level1/core"),
+    utils = require("../utils"),
+    defineGetter = utils.defineGetter,
+    defineSetter = utils.defineSetter,
+    inheritFrom = utils.inheritFrom;
+
+// The dependencies here are a bit screwy; when we get a chance to move all events to living, things will get simpler.
+const Event = require("../living/generated/Event");
+const CustomEvent = require("../living/generated/CustomEvent");
+const MessageEvent = require("../living/generated/MessageEvent");
+const ErrorEvent = require("../living/generated/ErrorEvent");
+const HashChangeEvent = require("../living/generated/HashChangeEvent");
+const UIEvent = require("../living/generated/UIEvent");
+const MouseEvent = require("../living/generated/MouseEvent");
+const KeyboardEvent = require("../living/generated/KeyboardEvent");
+const TouchEvent = require("../living/generated/TouchEvent");
+const MutationEvent = require("../living/generated/MutationEvent");
+const ProgressEvent = require("../living/generated/ProgressEvent");
+const domSymbolTree = require("../living/helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("../living/node-type");
+
+core.Event = Event.interface;
+core.CustomEvent = CustomEvent.interface;
+core.MessageEvent = MessageEvent.interface;
+core.ErrorEvent = ErrorEvent.interface;
+core.HashChangeEvent = HashChangeEvent.interface;
+core.UIEvent = UIEvent.interface;
+core.MouseEvent = MouseEvent.interface;
+core.KeyboardEvent = KeyboardEvent.interface;
+core.TouchEvent = TouchEvent.interface;
+core.MutationEvent = MutationEvent.interface;
+core.ProgressEvent = ProgressEvent.interface;
+
+core.EventTarget = require('../living/generated/EventTarget').interface;
+
+// Reinherit class heirarchy with EventTarget at its root
+inheritFrom(core.EventTarget, core.Node, core.Node.prototype);
+
+// Node
+inheritFrom(core.Node, core.Document, core.Document.prototype);
+inheritFrom(core.Node, core.DocumentFragment, core.DocumentFragment.prototype);
+inheritFrom(core.Node, core.Element, core.Element.prototype);
+
+
+function getDocument(el) {
+  return el.nodeType == NODE_TYPE.DOCUMENT_NODE ? el : el._ownerDocument;
+}
+
+function mutationEventsEnabled(el) {
+  return el.nodeType != NODE_TYPE.ATTRIBUTE_NODE &&
+         getDocument(el).implementation._hasFeature('MutationEvents');
+}
+
+var insertBefore_super = core.Node.prototype.insertBefore;
+core.Node.prototype.insertBefore = function(newChild, refChild) {
+  var ret = insertBefore_super.apply(this, arguments);
+  if (mutationEventsEnabled(this)) {
+    var doc = getDocument(this),
+        ev = doc.createEvent("MutationEvents");
+
+    ev.initMutationEvent("DOMNodeInserted", true, false, this, null, null, null, null);
+    newChild.dispatchEvent(ev);
+
+    ev = doc.createEvent("MutationEvents");
+    ev.initMutationEvent("DOMSubtreeModified", true, false, this, null, null, null, null);
+    this.dispatchEvent(ev);
+
+    if (this.nodeType == NODE_TYPE.DOCUMENT_NODE || this._attachedToDocument) {
+      ev = doc.createEvent("MutationEvents");
+      ev.initMutationEvent("DOMNodeInsertedIntoDocument", false, false, null, null, null, null, null);
+
+      for (const el of domSymbolTree.treeIterator(newChild)) {
+        if (el.nodeType == NODE_TYPE.ELEMENT_NODE) {
+          el.dispatchEvent(ev);
+          el._attachedToDocument = true;
+        }
+      }
+    }
+  }
+  return ret;
+};
+
+var removeChild_super = core.Node.prototype.removeChild;
+core.Node.prototype.removeChild = function (oldChild) {
+  if (mutationEventsEnabled(this)) {
+    var doc = getDocument(this),
+        ev = doc.createEvent("MutationEvents");
+
+    ev.initMutationEvent("DOMNodeRemoved", true, false, this, null, null, null, null);
+    oldChild.dispatchEvent(ev);
+
+    ev = doc.createEvent("MutationEvents");
+    ev.initMutationEvent("DOMSubtreeModified", true, false, this, null, null, null, null);
+    this.dispatchEvent(ev);
+
+    ev = doc.createEvent("MutationEvents");
+    ev.initMutationEvent("DOMNodeRemovedFromDocument", false, false, null, null, null, null, null);
+    for (const el of domSymbolTree.treeIterator(oldChild)) {
+      if (el.nodeType == NODE_TYPE.ELEMENT_NODE) {
+        el.dispatchEvent(ev);
+        el._attachedToDocument = false;
+      }
+    }
+  }
+  return removeChild_super.apply(this, arguments);
+};
+
+
+var _attrModified_super = core.Node.prototype._attrModified;
+core.Node.prototype._attrModified = function (name, value, oldValue) {
+    var ret = _attrModified_super.apply(this, arguments);
+    if (mutationEventsEnabled(this) && value !== oldValue) {
+        var doc = getDocument(this),
+            ev = doc.createEvent("MutationEvents");
+
+        ev.initMutationEvent("DOMSubtreeModified", true, false, this, null, null, null, null);
+        this.dispatchEvent(ev);
+    }
+    return ret;
+};
+
+var interfaceTable = {
+  event: Event,
+  events: Event,
+  htmlevents: Event,
+  mouseevent: MouseEvent,
+  mouseevents: MouseEvent,
+  uievent: UIEvent,
+  uievents: UIEvent,
+  messageevent: MessageEvent,
+
+  customevent: CustomEvent,
+  keyboardevent: KeyboardEvent,
+  keyevents: KeyboardEvent,
+  touchevent: TouchEvent,
+
+  // old, not part of spec anymore
+  mutationevents: MutationEvent
+};
+
+core.Document.prototype.createEvent = function (type) {
+  var typeLower = type.toLowerCase();
+  var Event = interfaceTable[typeLower] || null;
+
+  if (!Event) {
+    throw new core.DOMException(core.DOMException.NOT_SUPPORTED_ERR,
+      "The provided event type (\"" + type + "\") is invalid");
+  }
+
+  return Event.create([""]);
+};

node_modules/jsdom/lib/jsdom/level2/languages/javascript.js

@@ -0,0 +1,20 @@
+"use strict";
+const vm = require("vm");
+const reportException = require("../../living/helpers/runtime-script-errors");
+
+exports.javascript = function (element, code, filename) {
+  const document = element.ownerDocument;
+  const window = document && document._global;
+
+  if (window) {
+    window.document._currentScript = element;
+
+    try {
+      vm.runInContext(code, window, { filename, displayErrors: false });
+    } catch (e) {
+      reportException(window, e, filename);
+    } finally {
+      window.document._currentScript = null;
+    }
+  }
+};

node_modules/jsdom/lib/jsdom/level2/style.js

@@ -0,0 +1,198 @@
+"use strict";
+var resourceLoader = require('../browser/resource-loader'),
+    core = require("../level1/core"),
+    utils = require("../utils"),
+    defineGetter = utils.defineGetter,
+    inheritFrom = utils.inheritFrom,
+    cssom = require("cssom"),
+    cssstyle = require("cssstyle"),
+    resolveHref = require("../utils").resolveHref,
+    assert = require('assert');
+
+const domSymbolTree = require("../living/helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("../living/node-type");
+
+// 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;
+
+// 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
+
+// http://dev.w3.org/csswg/cssom/#stylesheetlist
+function StyleSheetList() {}
+
+StyleSheetList.prototype.__proto__ = Array.prototype;
+
+StyleSheetList.prototype.item = function item(i) {
+  return this[i];
+};
+
+core.StyleSheetList = StyleSheetList;
+
+// http://dev.w3.org/csswg/cssom/#extensions-to-the-document-interface
+defineGetter(core.Document.prototype, 'styleSheets', function () {
+  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;
+});
+
+
+/**
+ * @this {core.HTMLLinkElement|core.HTMLStyleElement}
+ * @param {string} url
+ * @param {cssom.CSSStyleSheet} sheet
+ * @see http://dev.w3.org/csswg/cssom/#requirements-on-user-agents-implementing0
+ */
+function fetchStylesheet(url, sheet) {
+  resourceLoader.load(this, url, function(data) {
+    // TODO: abort if the content-type is not text/css, and the document is
+    // in strict mode
+    url = sheet.href = resourceLoader.resolveResourceUrl(this.ownerDocument, url);
+    evaluateStylesheet.call(this, data, sheet, url);
+  });
+}
+/**
+ * @this {core.HTMLLinkElement|core.HTMLStyleElement}
+ * @param {string} data
+ * @param {cssom.CSSStyleSheet} sheet
+ * @param {string} baseUrl
+ */
+function evaluateStylesheet(data, sheet, baseUrl) {
+  // this is the element
+  var newStyleSheet = cssom.parse(data);
+  var spliceArgs = newStyleSheet.cssRules;
+  spliceArgs.unshift(0, sheet.cssRules.length);
+  Array.prototype.splice.apply(sheet.cssRules, spliceArgs);
+  scanForImportRules.call(this, sheet.cssRules, baseUrl);
+  this.ownerDocument.styleSheets.push(sheet);
+}
+/**
+ * @this {core.HTMLLinkElement|core.HTMLStyleElement}
+ * @param {cssom.CSSStyleSheet} sheet
+ * @param {string} baseUrl
+ */
+function scanForImportRules(cssRules, baseUrl) {
+  if (!cssRules) return;
+  for (var i = 0; i < cssRules.length; ++i) {
+    if (cssRules[i].cssRules) {
+      // @media rule: keep searching inside it.
+      scanForImportRules.call(this, 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.
+      fetchStylesheet.call(this, resolveHref(baseUrl, cssRules[i].href), this.sheet);
+    }
+  }
+}
+
+assert.equal(undefined, core.HTMLLinkElement._init);
+core.HTMLLinkElement._init = function() {
+  this.addEventListener('DOMNodeInsertedIntoDocument', function() {
+    if (!/(?:[ \t\n\r\f]|^)stylesheet(?:[ \t\n\r\f]|$)/i.test(this.rel)) {
+      // rel is a space-separated list of tokens, and the original rel types
+      // are case-insensitive.
+      return;
+    }
+    if (this.href) {
+      fetchStylesheet.call(this, this.href, this.sheet);
+    }
+  });
+};
+
+assert.equal(undefined, core.HTMLStyleElement._init);
+core.HTMLStyleElement._init = function() {
+  //console.log('init style')
+  this.addEventListener('DOMNodeInsertedIntoDocument', function() {
+    //console.log('style inserted')
+    //console.log('sheet: ', this.sheet);
+    if (this.type && this.type !== 'text/css') {
+      //console.log('bad type: ' + this.type)
+      return;
+    }
+
+    let content = '';
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child.nodeType === NODE_TYPE.TEXT_NODE) {
+        content += child.nodeValue;
+      }
+    }
+
+    evaluateStylesheet.call(this, content, this.sheet, this._ownerDocument.URL);
+  });
+};
+
+
+// https://html.spec.whatwg.org/multipage/semantics.html#htmllinkelement:
+// HTMLLinkElement implements LinkStyle
+
+// https://html.spec.whatwg.org/multipage/semantics.html#htmlstyleelement:
+// HTMLStyleElement implements LinkStyle
+
+// from http://dev.w3.org/csswg/cssom/#the-linkstyle-interface
+
+// A future refactoring would be to place _cssStyleSheet on all HTMLLinkElement and HTMLStyleElement instances, in
+// their constructor, initially set to null. Then, successful loading of the stylesheet object would set it to
+// non-null. The getter would just always return the current value. This would make it more correctly be null before
+// loading, and on load failure, and would allow access to _cssStyleSheet instead of the public .sheet API.
+
+function getOrCreateSheet() {
+  if (!this._cssStyleSheet) {
+    this._cssStyleSheet = new cssom.CSSStyleSheet();
+  }
+  return this._cssStyleSheet;
+}
+
+defineGetter(core.HTMLLinkElement.prototype, 'sheet', getOrCreateSheet);
+defineGetter(core.HTMLStyleElement.prototype, 'sheet', getOrCreateSheet);

node_modules/jsdom/lib/jsdom/level3/core.js

@@ -0,0 +1,534 @@
+"use strict";
+var core          = require("../level1/core"),
+    defineGetter  = require('../utils').defineGetter,
+    defineSetter  = require('../utils').defineSetter,
+    HtmlToDom     = require('../browser/htmltodom').HtmlToDom;
+
+const domSymbolTree = require("../living/helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("../living/node-type");
+
+/*
+  valuetype DOMString sequence<unsigned short>;
+  typedef   unsigned long long DOMTimeStamp;
+  typedef   any DOMUserData;
+  typedef   Object DOMObject;
+
+*/
+/*
+  // Introduced in DOM Level 3:
+  interface NameList {
+    DOMString          getName(in unsigned long index);
+    DOMString          getNamespaceURI(in unsigned long index);
+    readonly attribute unsigned long   length;
+    boolean            contains(in DOMString str);
+    boolean            containsNS(in DOMString namespaceURI,
+                                  in DOMString name);
+  };
+
+  // Introduced in DOM Level 3:
+  interface DOMImplementationList {
+    DOMImplementation  item(in unsigned long index);
+    readonly attribute unsigned long   length;
+  };
+
+  // Introduced in DOM Level 3:
+  interface DOMImplementationSource {
+    DOMImplementation  getDOMImplementation(in DOMString features);
+    DOMImplementationList getDOMImplementationList(in DOMString features);
+  };
+*/
+
+
+core.DOMImplementation.prototype.getFeature = function(feature, version)  {
+
+};
+
+/*
+  interface Node {
+    // Modified in DOM Level 3:
+    Node               insertBefore(in Node newChild,
+                                    in Node refChild)
+                                        raises(DOMException);
+    // Modified in DOM Level 3:
+    Node               replaceChild(in Node newChild,
+                                    in Node oldChild)
+                                        raises(DOMException);
+    // Modified in DOM Level 3:
+    Node               removeChild(in Node oldChild)
+                                        raises(DOMException);
+    // Modified in DOM Level 3:
+    Node               appendChild(in Node newChild)
+                                        raises(DOMException);
+    boolean            hasChildNodes();
+    Node               cloneNode(in boolean deep);
+    // Modified in DOM Level 3:
+    void               normalize();
+    // Introduced in DOM Level 3:
+    readonly attribute DOMString       baseURI;
+*/
+
+// Compare Document Position
+var DOCUMENT_POSITION_DISCONNECTED = core.Node.DOCUMENT_POSITION_DISCONNECTED =
+                                     core.Node.prototype.DOCUMENT_POSITION_DISCONNECTED = 0x01;
+
+var DOCUMENT_POSITION_PRECEDING    = core.Node.DOCUMENT_POSITION_PRECEDING =
+                                     core.Node.prototype.DOCUMENT_POSITION_PRECEDING    = 0x02;
+
+var DOCUMENT_POSITION_FOLLOWING    = core.Node.DOCUMENT_POSITION_FOLLOWING =
+                                     core.Node.prototype.DOCUMENT_POSITION_FOLLOWING    = 0x04;
+
+var DOCUMENT_POSITION_CONTAINS     = core.Node.DOCUMENT_POSITION_CONTAINS =
+                                     core.Node.prototype.DOCUMENT_POSITION_CONTAINS     = 0x08;
+
+var DOCUMENT_POSITION_CONTAINED_BY = core.Node.DOCUMENT_POSITION_CONTAINED_BY =
+                                     core.Node.prototype.DOCUMENT_POSITION_CONTAINED_BY = 0x10;
+
+var DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = core.Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC =
+                                                core.Node.prototype.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
+
+// @see http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#Node3-textContent
+defineGetter(core.Node.prototype, 'textContent', function() {
+  let text;
+  switch (this.nodeType) {
+    case NODE_TYPE.COMMENT_NODE:
+    case NODE_TYPE.CDATA_SECTION_NODE:
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+    case NODE_TYPE.TEXT_NODE:
+      return this.nodeValue;
+
+    case NODE_TYPE.ATTRIBUTE_NODE:
+    case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+    case NODE_TYPE.ELEMENT_NODE:
+      text = '';
+      for (const child of domSymbolTree.treeIterator(this)) {
+        if (child.nodeType === NODE_TYPE.TEXT_NODE) {
+          text += child.nodeValue;
+        }
+      }
+      return text;
+
+    default:
+      return null;
+  }
+});
+
+defineSetter(core.Node.prototype, 'textContent', function(txt) {
+  switch (this.nodeType) {
+    case NODE_TYPE.COMMENT_NODE:
+    case NODE_TYPE.CDATA_SECTION_NODE:
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+    case NODE_TYPE.TEXT_NODE:
+      return this.nodeValue = String(txt);
+  }
+
+  for (let child = null; child = domSymbolTree.firstChild(this);) {
+    this.removeChild(child);
+  }
+
+  if (txt !== "" && txt != null) {
+    this.appendChild(this._ownerDocument.createTextNode(txt));
+  }
+  return txt;
+});
+
+/*
+    // Introduced in DOM Level 3:
+    DOMString          lookupPrefix(in DOMString namespaceURI);
+    // Introduced in DOM Level 3:
+    boolean            isDefaultNamespace(in DOMString namespaceURI);
+    // Introduced in DOM Level 3:
+    DOMString          lookupNamespaceURI(in DOMString prefix);
+    // Introduced in DOM Level 3:
+    DOMObject          getFeature(in DOMString feature,
+                                  in DOMString version);
+*/
+// Introduced in DOM Level 3:
+core.Node.prototype.setUserData = function(key, data, handler) {
+  var r = this[key] || null;
+  this[key] = data;
+  return(r);
+};
+
+// Introduced in DOM Level 3:
+core.Node.prototype.getUserData = function(key) {
+  var r = this[key] || null;
+  return(r);
+};
+/*
+  interface NodeList {
+    Node               item(in unsigned long index);
+    readonly attribute unsigned long   length;
+  };
+
+  interface NamedNodeMap {
+    Node               getNamedItem(in DOMString name);
+    Node               setNamedItem(in Node arg)
+                                        raises(DOMException);
+    Node               removeNamedItem(in DOMString name)
+                                        raises(DOMException);
+    Node               item(in unsigned long index);
+    readonly attribute unsigned long   length;
+    // Introduced in DOM Level 2:
+    Node               getNamedItemNS(in DOMString namespaceURI,
+                                      in DOMString localName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    Node               setNamedItemNS(in Node arg)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    Node               removeNamedItemNS(in DOMString namespaceURI,
+                                         in DOMString localName)
+                                        raises(DOMException);
+  };
+
+  interface CharacterData : Node {
+             attribute DOMString       data;
+                                        // raises(DOMException) on setting
+                                        // raises(DOMException) on retrieval
+
+    readonly attribute unsigned long   length;
+    DOMString          substringData(in unsigned long offset,
+                                     in unsigned long count)
+                                        raises(DOMException);
+    void               appendData(in DOMString arg)
+                                        raises(DOMException);
+    void               insertData(in unsigned long offset,
+                                  in DOMString arg)
+                                        raises(DOMException);
+    void               deleteData(in unsigned long offset,
+                                  in unsigned long count)
+                                        raises(DOMException);
+    void               replaceData(in unsigned long offset,
+                                   in unsigned long count,
+                                   in DOMString arg)
+                                        raises(DOMException);
+  };
+
+  interface Attr : Node {
+    readonly attribute DOMString       name;
+    readonly attribute boolean         specified;
+             attribute DOMString       value;
+                                        // raises(DOMException) on setting
+
+    // Introduced in DOM Level 2:
+    readonly attribute Element         ownerElement;
+    // Introduced in DOM Level 3:
+    readonly attribute TypeInfo        schemaTypeInfo;
+
+*/
+    // Introduced in DOM Level 3:
+/*
+  };
+
+  interface Element : Node {
+    readonly attribute DOMString       tagName;
+    DOMString          getAttribute(in DOMString name);
+    void               setAttribute(in DOMString name,
+                                    in DOMString value)
+                                        raises(DOMException);
+    void               removeAttribute(in DOMString name)
+                                        raises(DOMException);
+    Attr               getAttributeNode(in DOMString name);
+    Attr               setAttributeNode(in Attr newAttr)
+                                        raises(DOMException);
+    Attr               removeAttributeNode(in Attr oldAttr)
+                                        raises(DOMException);
+    NodeList           getElementsByTagName(in DOMString name);
+    // Introduced in DOM Level 2:
+    DOMString          getAttributeNS(in DOMString namespaceURI,
+                                      in DOMString localName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    void               setAttributeNS(in DOMString namespaceURI,
+                                      in DOMString qualifiedName,
+                                      in DOMString value)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    void               removeAttributeNS(in DOMString namespaceURI,
+                                         in DOMString localName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    Attr               getAttributeNodeNS(in DOMString namespaceURI,
+                                          in DOMString localName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    Attr               setAttributeNodeNS(in Attr newAttr)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    NodeList           getElementsByTagNameNS(in DOMString namespaceURI,
+                                              in DOMString localName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    boolean            hasAttribute(in DOMString name);
+    // Introduced in DOM Level 2:
+    boolean            hasAttributeNS(in DOMString namespaceURI,
+                                      in DOMString localName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 3:
+    readonly attribute TypeInfo        schemaTypeInfo;
+    // Introduced in DOM Level 3:
+    void               setIdAttribute(in DOMString name,
+                                      in boolean isId)
+                                        raises(DOMException);
+    // Introduced in DOM Level 3:
+    void               setIdAttributeNS(in DOMString namespaceURI,
+                                        in DOMString localName,
+                                        in boolean isId)
+                                        raises(DOMException);
+    // Introduced in DOM Level 3:
+    void               setIdAttributeNode(in Attr idAttr,
+                                          in boolean isId)
+                                        raises(DOMException);
+  };
+
+  interface Text : CharacterData {
+    Text               splitText(in unsigned long offset)
+                                        raises(DOMException);
+    // Introduced in DOM Level 3:
+    readonly attribute boolean         isElementContentWhitespace;
+    // Introduced in DOM Level 3:
+    readonly attribute DOMString       wholeText;
+    // Introduced in DOM Level 3:
+    Text               replaceWholeText(in DOMString content)
+                                        raises(DOMException);
+  };
+
+  interface Comment : CharacterData {
+  };
+
+  // Introduced in DOM Level 3:
+  interface TypeInfo {
+    readonly attribute DOMString       typeName;
+    readonly attribute DOMString       typeNamespace;
+
+    // DerivationMethods
+    const unsigned long       DERIVATION_RESTRICTION         = 0x00000001;
+    const unsigned long       DERIVATION_EXTENSION           = 0x00000002;
+    const unsigned long       DERIVATION_UNION               = 0x00000004;
+    const unsigned long       DERIVATION_LIST                = 0x00000008;
+
+    boolean            isDerivedFrom(in DOMString typeNamespaceArg,
+                                     in DOMString typeNameArg,
+                                     in unsigned long derivationMethod);
+  };
+*/
+// Introduced in DOM Level 3:
+core.UserDataHandler = function() {};
+core.UserDataHandler.prototype.NODE_CLONED   = 1;
+core.UserDataHandler.prototype.NODE_IMPORTED = 2;
+core.UserDataHandler.prototype.NODE_DELETED  = 3;
+core.UserDataHandler.prototype.NODE_RENAMED  = 4;
+core.UserDataHandler.prototype.NODE_ADOPTED  = 5;
+core.UserDataHandler.prototype.handle = function(operation, key, data, src, dst) {};
+
+// Introduced in DOM Level 3:
+core.DOMError = function(severity, message, type, relatedException, relatedData, location) {
+  this._severity         = severity;
+  this._message          = message;
+  this._type             = type;
+  this._relatedException = relatedException;
+  this._relatedData      = relatedData;
+  this._location         = location;
+};
+core.DOMError.prototype = {};
+core.DOMError.prototype.SEVERITY_WARNING     = 1;
+core.DOMError.prototype.SEVERITY_ERROR       = 2;
+core.DOMError.prototype.SEVERITY_FATAL_ERROR = 3;
+defineGetter(core.DOMError.prototype, 'severity', function() {
+  return this._severity;
+});
+defineGetter(core.DOMError.prototype, 'message', function() {
+  return this._message;
+});
+defineGetter(core.DOMError.prototype, 'type', function() {
+  return this._type;
+});
+defineGetter(core.DOMError.prototype, 'relatedException', function() {
+  return this._relatedException;
+});
+defineGetter(core.DOMError.prototype, 'relatedData', function() {
+  return this._relatedData;
+});
+defineGetter(core.DOMError.prototype, 'location', function() {
+  return this._location;
+});
+
+/*
+  // Introduced in DOM Level 3:
+  interface DOMErrorHandler {
+    boolean            handleError(in DOMError error);
+  };
+
+  // Introduced in DOM Level 3:
+  interface DOMLocator {
+    readonly attribute long            lineNumber;
+    readonly attribute long            columnNumber;
+    readonly attribute long            byteOffset;
+    readonly attribute long            utf16Offset;
+    readonly attribute Node            relatedNode;
+    readonly attribute DOMString       uri;
+  };
+*/
+
+// Introduced in DOM Level 3:
+core.DOMConfiguration = function(){
+  var possibleParameterNames = {
+    'canonical-form': [false, true], // extra rules for true
+    'cdata-sections': [true, false],
+    'check-character-normalization': [false, true],
+    'comments': [true, false],
+    'datatype-normalization': [false, true],
+    'element-content-whitespace': [true, false],
+    'entities': [true, false],
+    // 'error-handler': [],
+    'infoset': [undefined, true, false], // extra rules for true
+    'namespaces': [true, false],
+    'namespace-declarations': [true, false], // only checked if namespaces is true
+    'normalize-characters': [false, true],
+    // 'schema-location': [],
+    // 'schema-type': [],
+    'split-cdata-sections': [true, false],
+    'validate': [false, true],
+    'validate-if-schema': [false, true],
+    'well-formed': [true, false]
+  }
+};
+
+core.DOMConfiguration.prototype = {
+  setParameter: function(name, value) {},
+  getParameter: function(name) {},
+  canSetParameter: function(name, value) {},
+  parameterNames: function() {}
+};
+
+//core.Document.prototype._domConfig = new core.DOMConfiguration();
+defineGetter(core.Document.prototype, 'domConfig', function() {
+  return this._domConfig || new core.DOMConfiguration();;
+});
+
+// Introduced in DOM Level 3:
+core.DOMStringList = function() {};
+
+core.DOMStringList.prototype = {
+  item: function() {},
+  length: function() {},
+  contains: function() {}
+};
+
+
+/*
+  interface CDATASection : Text {
+  };
+
+  interface DocumentType : Node {
+    readonly attribute DOMString       name;
+    readonly attribute NamedNodeMap    entities;
+    readonly attribute NamedNodeMap    notations;
+    // Introduced in DOM Level 2:
+    readonly attribute DOMString       publicId;
+    // Introduced in DOM Level 2:
+    readonly attribute DOMString       systemId;
+    // Introduced in DOM Level 2:
+    readonly attribute DOMString       internalSubset;
+  };
+
+  interface Notation : Node {
+    readonly attribute DOMString       publicId;
+    readonly attribute DOMString       systemId;
+  };
+
+  interface Entity : Node {
+    readonly attribute DOMString       publicId;
+    readonly attribute DOMString       systemId;
+    readonly attribute DOMString       notationName;
+    // Introduced in DOM Level 3:
+    readonly attribute DOMString       inputEncoding;
+    // Introduced in DOM Level 3:
+    readonly attribute DOMString       xmlEncoding;
+    // Introduced in DOM Level 3:
+    readonly attribute DOMString       xmlVersion;
+  };
+
+  interface EntityReference : Node {
+  };
+
+  interface ProcessingInstruction : Node {
+    readonly attribute DOMString       target;
+             attribute DOMString       data;
+                                        // raises(DOMException) on setting
+
+  };
+
+  interface DocumentFragment : Node {
+  };
+
+  interface Document : Node {
+    // Modified in DOM Level 3:
+    readonly attribute DocumentType    doctype;
+    readonly attribute DOMImplementation implementation;
+    readonly attribute Element         documentElement;
+    Element            createElement(in DOMString tagName)
+                                        raises(DOMException);
+    DocumentFragment   createDocumentFragment();
+    Text               createTextNode(in DOMString data);
+    Comment            createComment(in DOMString data);
+    CDATASection       createCDATASection(in DOMString data)
+                                        raises(DOMException);
+    ProcessingInstruction createProcessingInstruction(in DOMString target,
+                                                      in DOMString data)
+                                        raises(DOMException);
+    Attr               createAttribute(in DOMString name)
+                                        raises(DOMException);
+    EntityReference    createEntityReference(in DOMString name)
+                                        raises(DOMException);
+    NodeList           getElementsByTagName(in DOMString tagname);
+    // Introduced in DOM Level 2:
+    Node               importNode(in Node importedNode,
+                                  in boolean deep)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    Element            createElementNS(in DOMString namespaceURI,
+                                       in DOMString qualifiedName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    Attr               createAttributeNS(in DOMString namespaceURI,
+                                         in DOMString qualifiedName)
+                                        raises(DOMException);
+    // Introduced in DOM Level 2:
+    NodeList           getElementsByTagNameNS(in DOMString namespaceURI,
+                                              in DOMString localName);
+    // Introduced in DOM Level 2:
+    Element            getElementById(in DOMString elementId);
+*/
+/*
+    // Introduced in DOM Level 3:
+    readonly attribute DOMString       xmlEncoding;
+    // Introduced in DOM Level 3:
+             attribute boolean         xmlStandalone;
+                                        // raises(DOMException) on setting
+
+    // Introduced in DOM Level 3:
+             attribute DOMString       xmlVersion;
+                                        // raises(DOMException) on setting
+
+    // Introduced in DOM Level 3:
+             attribute boolean         strictErrorChecking;
+    // Introduced in DOM Level 3:
+             attribute DOMString       documentURI;
+    // Introduced in DOM Level 3:
+    Node               adoptNode(in Node source)
+                                        raises(DOMException);
+    // Introduced in DOM Level 3:
+    readonly attribute DOMConfiguration domConfig;
+    // Introduced in DOM Level 3:
+    void               normalizeDocument();
+    // Introduced in DOM Level 3:
+    Node               renameNode(in Node n,
+                                  in DOMString namespaceURI,
+                                  in DOMString qualifiedName)
+                                        raises(DOMException);
+  };
+};
+
+#endif // _DOM_IDL_
+*/

node_modules/jsdom/lib/jsdom/level3/ls.js

@@ -0,0 +1,211 @@
+// w3c Load/Save functionality: http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/
+
+var core = require('../level1/core');
+var createFrom = require('../utils').createFrom;
+
+var ls = {};
+
+// TODO: what is this?
+//typedef dom::DOMConfiguration DOMConfiguration;
+
+ls.LSException = function LSException(code) {
+  this.code = code;
+};
+
+ls.LSException.prototype = {
+  // LSExceptionCode
+  PARSE_ERR                       : 81,
+  SERIALIZE_ERR                   : 82
+};
+
+ls.DOMImplementationLS = function DOMImplementationLS() {
+
+};
+
+var DOMImplementationExtension = {
+
+  // DOMImplementationLSMode
+  MODE_SYNCHRONOUS  : 1,
+  MODE_ASYNCHRONOUS : 2,
+
+  // raises(dom::DOMException);
+  createLSParser : function(/* int */ mode, /* string */ schemaType) {
+    return new ls.LSParser(mode, schemaType);
+  },
+
+  createLSSerializer : function() {
+    return new ls.LSSerializer();
+  },
+
+  createLSInput : function() {
+    return new ls.LSInput();
+  },
+
+  createLSOutput : function() {
+    return new ls.LSOutput();
+  }
+};
+
+Object.keys(DOMImplementationExtension).forEach(function(k, v) {
+  core.DOMImplementation.prototype[k] = DOMImplementationExtension[k];
+});
+
+ls.DOMImplementationLS.prototype = DOMImplementationExtension;
+
+core.Document.getFeature = function() {
+  return DOMImplementationExtension;
+};
+
+ls.LSParser = function LSParser() {
+  this._domConfig = new core.DOMConfiguration();
+};
+ls.LSParser.prototype = {
+  get domConfig() { return this._domConfig; },
+  get filter() { return this._filter || null; },
+  set filter(value) { this._filter = value; },
+  get async() { return this._async; },
+  get busy() { return this._busy; },
+
+  // raises(dom::DOMException, LSException);
+  parse : function (/* LSInput */ input) {
+    var doc = new core.Document();
+    doc._inputEncoding = 'UTF-16';
+    return doc;
+  },
+
+  // raises(dom::DOMException, LSException);
+  parseURI : function(/* string */ uri) {
+    return new core.Document();
+  },
+
+  // ACTION_TYPES
+  ACTION_APPEND_AS_CHILDREN       : 1,
+  ACTION_REPLACE_CHILDREN         : 2,
+  ACTION_INSERT_BEFORE            : 3,
+  ACTION_INSERT_AFTER             : 4,
+  ACTION_REPLACE                  : 5,
+
+  // @returns Node
+  // @raises DOMException, LSException
+  parseWithContext                : function(/* LSInput */ input, /* Node */ contextArg, /* int */ action) {
+    return new core.Node();
+  },
+
+  abort                           : function() {
+    // TODO: implement
+  }
+};
+
+ls.LSInput = function LSInput() {};
+ls.LSInput.prototype = {
+  get characterStream() { return this._characterStream || null; },
+  set characterStream(value) { this._characterStream = value; },
+  get byteStream() { return this._byteStream || null; },
+  set byteStream(value) { this._byteStream = value; },
+  get stringData() { return this._stringData || null; },
+  set stringData(value) { this._stringData = value; },
+  get systemId() { return this._systemId || null; },
+  set systemId(value) { this._systemId = value; },
+  get publicId() { return this._publicId || null; },
+  set publicId(value) { this._publicId = value; },
+  get baseURI() { return this._baseURI || null; },
+  set baseURI(value) { this._baseURI = value; },
+  get encoding() { return this._encoding || null; },
+  set encoding(value) { this._encoding = value; },
+  get certifiedText() { return this._certifiedText || null; },
+  set certifiedText(value) { this._certifiedText = value; },
+};
+
+ls.LSResourceResolver = function LSResourceResolver() {};
+
+// @returns LSInput
+ls.LSResourceResolver.prototype.resolveResource = function(type, namespaceURI, publicId, systemId, baseURI) {
+  return new ls.LSInput();
+};
+
+ls.LSParserFilter = function LSParserFilter() {};
+ls.LSParserFilter.prototype = {
+
+  // Constants returned by startElement and acceptNode
+  FILTER_ACCEPT                   : 1,
+  FILTER_REJECT                   : 2,
+  FILTER_SKIP                     : 3,
+  FILTER_INTERRUPT                : 4,
+
+  get whatToShow() { return this._whatToShow; },
+
+  // @returns int
+  startElement : function(/* Element */ elementArg) {
+    return 0;
+  },
+
+  // @returns int
+  acceptNode : function(/* Node */ nodeArg) {
+    return nodeArg;
+  }
+};
+
+ls.LSSerializer = function LSSerializer() {
+  this._domConfig = new core.DOMConfiguration();
+};
+ls.LSSerializer.prototype = {
+  get domConfig() { return this._domConfig; },
+  get newLine() { return this._newLine || null; },
+  set newLine(value) { this._newLine = value; },
+  get filter() { return this._filter || null; },
+  set filter(value) { this._filter = value; },
+
+  // @returns boolean
+  // @raises LSException
+  write : function(/* Node */ nodeArg, /* LSOutput */ destination) {
+   return true;
+  },
+
+  // @returns boolean
+  // @raises LSException
+  writeToURI : function(/* Node */ nodeArg, /* string */ uri) {
+   return true;
+  },
+
+  // @returns string
+  // @raises DOMException, LSException
+  writeToString : function(/* Node */ nodeArg) {
+    return "";
+  }
+};
+
+ls.LSOutput = function LSOutput() {};
+ls.LSOutput.prototype = {
+  get characterStream() { return this._characterStream || null; },
+  set characterStream(value) { this._characterStream = value; },
+  get byteStream() { return this._byteStream || null; },
+  set byteStream(value) { this._byteStream = value; },
+  get systemId() { return this._systemId || null; },
+  set systemId(value) { this._systemId = value; },
+  get encoding() { return this._encoding || null; },
+  set encoding(value) { this._encoding = value; },
+};
+
+ls.LSProgressEvent = function LSProgressEvent() {};
+ls.LSProgressEvent.prototype = createFrom(core.Event, {
+  constructor: ls.LSProgressEvent,
+  get input() { return this._input; },
+  get position() { return this._position; },
+  get totalSize() { return this._totalSize; },
+});
+
+ls.LSLoadEvent = function LSLoadEvent() {};
+ls.LSLoadEvent.prototype = createFrom(core.Event, {
+  get newDocument() { return this._newDocument; },
+  get input() { return this._input; },
+});
+
+
+// TODO: do traversal
+ls.LSSerializerFilter = function LSSerializerFilter() {};
+ls.LSSerializerFilter.prototype = {
+  get whatToShow() { return this._whatToShow; },
+};
+
+// ls.LSSerializerFilter.prototype.__proto__ = level2.traversal.NodeFiler;
+

node_modules/jsdom/lib/jsdom/living/attributes.js

@@ -0,0 +1,419 @@
+"use strict";
+const DOMException = require("../web-idl/DOMException");
+const defineGetter = require("../utils").defineGetter;
+const idlUtils = require("./generated/utils");
+const attrGenerated = require("./generated/Attr");
+const changeAttributeImpl = require("./attributes/Attr-impl").changeAttributeImpl;
+const getAttrImplQualifiedName = require("./attributes/Attr-impl").getAttrImplQualifiedName;
+
+// https://dom.spec.whatwg.org/#namednodemap
+
+const INTERNAL = Symbol("NamedNodeMap internal");
+
+// TODO: use NamedPropertyTracker when https://github.com/tmpvar/jsdom/pull/1116 lands?
+
+// Don't emulate named getters for these properties.
+// Compiled later after NamedNodeMap is all set up.
+const reservedNames = new Set();
+
+function NamedNodeMap() {
+  throw new TypeError("Illegal constructor");
+}
+
+defineGetter(NamedNodeMap.prototype, "length", function () {
+  return this[INTERNAL].attributeList.length;
+});
+
+NamedNodeMap.prototype.item = function (index) {
+  if (arguments.length < 1) {
+    throw new TypeError("Not enough arguments to NamedNodeMap.prototype.item");
+  }
+
+  // Don't bother with full unsigned long long conversion. When we have better WebIDL support generally, revisit.
+  index = Number(index);
+
+  return this[index] || null;
+};
+
+NamedNodeMap.prototype.getNamedItem = function (name) {
+  if (arguments.length < 1) {
+    throw new TypeError("Not enough arguments to NamedNodeMap.prototype.getNamedItem");
+  }
+  name = String(name);
+
+  return exports.getAttributeByName(this[INTERNAL].element, name);
+};
+
+NamedNodeMap.prototype.getNamedItemNS = function (namespace, localName) {
+  if (arguments.length < 2) {
+    throw new TypeError("Not enough arguments to NamedNodeMap.prototype.getNamedItemNS");
+  }
+  if (namespace === undefined || namespace === null) {
+    namespace = null;
+  } else {
+    namespace = String(namespace);
+  }
+  localName = String(localName);
+
+  return exports.getAttributeByNameNS(this[INTERNAL].element, namespace, localName);
+};
+
+NamedNodeMap.prototype.setNamedItem = function (attr) {
+  if (!attrGenerated.is(attr)) {
+    throw new TypeError("First argument to NamedNodeMap.prototype.setNamedItem must be an Attr");
+  }
+
+  return exports.setAttribute(this[INTERNAL].element, attr);
+};
+
+NamedNodeMap.prototype.setNamedItemNS = function (attr) {
+  if (!attrGenerated.is(attr)) {
+    throw new TypeError("First argument to NamedNodeMap.prototype.setNamedItemNS must be an Attr");
+  }
+
+  return exports.setAttribute(this[INTERNAL].element, attr);
+};
+
+NamedNodeMap.prototype.removeNamedItem = function (name) {
+  if (arguments.length < 1) {
+    throw new TypeError("Not enough arguments to NamedNodeMap.prototype.getNamedItem");
+  }
+  name = String(name);
+
+  const attr = exports.removeAttributeByName(this[INTERNAL].element, name);
+
+  if (attr === null) {
+    throw new DOMException(DOMException.NOT_FOUND_ERR, "Tried to remove an attribute that was not present");
+  }
+
+  return attr;
+};
+
+NamedNodeMap.prototype.removeNamedItemNS = function (namespace, localName) {
+  if (arguments.length < 2) {
+    throw new TypeError("Not enough arguments to NamedNodeMap.prototype.removeNamedItemNS");
+  }
+  if (namespace === undefined || namespace === null) {
+    namespace = null;
+  } else {
+    namespace = String(namespace);
+  }
+  localName = String(localName);
+
+  const attr = exports.removeAttributeByNameNS(this[INTERNAL].element, namespace, localName);
+
+  if (attr === null) {
+    throw new DOMException(DOMException.NOT_FOUND_ERR, "Tried to remove an attribute that was not present");
+  }
+
+  return attr;
+};
+
+exports.NamedNodeMap = NamedNodeMap;
+
+{
+  let prototype = NamedNodeMap.prototype;
+  while (prototype) {
+    for (const name of Object.getOwnPropertyNames(prototype)) {
+      reservedNames.add(name);
+    }
+    prototype = Object.getPrototypeOf(prototype);
+  }
+}
+
+exports.createNamedNodeMap = function (element) {
+  const nnm = Object.create(NamedNodeMap.prototype);
+  nnm[INTERNAL] = {
+    element,
+    attributeList: [],
+    attributesByNameMap: new Map()
+  };
+  return nnm;
+};
+
+// 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.
+
+exports.hasAttribute = function (element, A) {
+  const attributesNNM = element._attributes;
+  const attributeList = attributesNNM[INTERNAL].attributeList;
+
+  return attributeList.indexOf(A) !== -1;
+};
+
+exports.hasAttributeByName = function (element, name) {
+  const attributesNNM = element._attributes;
+  const attributesByNameMap = attributesNNM[INTERNAL].attributesByNameMap;
+
+  return attributesByNameMap.has(name);
+};
+
+exports.hasAttributeByNameNS = function (element, namespace, localName) {
+  const attributesNNM = element._attributes;
+  const attributeList = attributesNNM[INTERNAL].attributeList;
+
+  return attributeList.some(attribute => {
+    const impl = idlUtils.implForWrapper(attribute);
+    return impl && impl._localName === localName && impl._namespace === namespace;
+  });
+};
+
+exports.changeAttribute = function (element, attribute, value) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-change
+
+  // The partitioning here works around a particularly bad circular require problem. See
+  // https://github.com/tmpvar/jsdom/pull/1247#issuecomment-149060470
+  changeAttributeImpl(element, idlUtils.implForWrapper(attribute), value);
+};
+
+exports.appendAttribute = function (element, attribute) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-append
+
+  const impl = idlUtils.implForWrapper(attribute);
+  const attributesNNM = element._attributes;
+  const attributeList = attributesNNM[INTERNAL].attributeList;
+
+  // TODO mutation observer stuff
+
+  attributeList.push(attribute);
+  impl._element = element;
+
+  // Sync target indexed properties
+  attributesNNM[attributeList.length - 1] = attribute;
+
+  // Sync target named properties
+  const name = getAttrImplQualifiedName(impl);
+  if (!reservedNames.has(name)) {
+    attributesNNM[name] = attribute;
+  }
+
+  // Sync name cache
+  const cache = attributesNNM[INTERNAL].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, impl._value, null);
+};
+
+exports.removeAttribute = function (element, attribute) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-remove
+
+  const attributesNNM = element._attributes;
+  const attributeList = attributesNNM[INTERNAL].attributeList;
+
+  // TODO mutation observer stuff
+
+  for (let i = 0; i < attributeList.length; ++i) {
+    if (attributeList[i] === attribute) {
+      const impl = idlUtils.implForWrapper(attribute);
+
+      attributeList.splice(i, 1);
+      impl._element = null;
+
+      // Sync target indexed properties
+      for (let j = i; j < attributeList.length; ++j) {
+        attributesNNM[j] = attributeList[j];
+      }
+      delete attributesNNM[attributeList.length];
+
+      // Sync target named properties
+      const name = getAttrImplQualifiedName(impl);
+      if (!reservedNames.has(name)) {
+        delete attributesNNM[name];
+      }
+
+      // Sync name cache
+      const cache = attributesNNM[INTERNAL].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, impl._value);
+
+      return;
+    }
+  }
+};
+
+exports.getAttributeByName = function (element, name) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
+
+  if (element._namespaceURI === "http://www.w3.org/1999/xhtml" &&
+      element._ownerDocument._parsingMode === "html") {
+    name = name.toLowerCase();
+  }
+
+  const cache = element._attributes[INTERNAL].attributesByNameMap;
+  const entry = cache.get(name);
+  if (!entry) {
+    return null;
+  }
+
+  return entry[0];
+};
+
+exports.getAttributeValue = function (element, name) {
+  const attr = exports.getAttributeByName(element, name);
+
+  if (!attr) {
+    return null;
+  }
+
+  return idlUtils.implForWrapper(attr)._value;
+};
+
+exports.getAttributeByNameNS = function (element, namespace, localName) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-get-by-namespace
+
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  const attributeList = element._attributes[INTERNAL].attributeList;
+  for (let i = 0; i < attributeList.length; ++i) {
+    const attr = attributeList[i];
+    const impl = idlUtils.implForWrapper(attr);
+    if (impl._namespace === namespace && impl._localName === localName) {
+      return attr;
+    }
+  }
+
+  return null;
+};
+
+exports.getAttributeValueByNameNS = function (element, namespace, localName) {
+  const attr = exports.getAttributeByNameNS(element, namespace, localName);
+
+  if (!attr) {
+    return null;
+  }
+
+  return idlUtils.implForWrapper(attr)._value;
+};
+
+exports.setAttribute = function (element, attr) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-set
+
+  const impl = idlUtils.implForWrapper(attr);
+
+  if (impl._element !== null && impl._element !== element) {
+    throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);
+  }
+
+  const oldAttr = exports.getAttributeByNameNS(element, impl._namespace, impl._localName);
+  if (oldAttr === attr) {
+    return attr;
+  }
+
+  if (oldAttr !== null) {
+    exports.removeAttribute(element, oldAttr);
+  }
+
+  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 = attrGenerated.create([], { namespace, namespacePrefix: prefix, localName, value });
+    exports.appendAttribute(element, newAttribute);
+    return;
+  }
+
+  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.copyAttributeList = function (sourceElement, destElement) {
+  // Needed by https://dom.spec.whatwg.org/#concept-node-clone
+
+  for (const sourceAttr of sourceElement._attributes[INTERNAL].attributeList) {
+    const sourceImpl = idlUtils.implForWrapper(sourceAttr);
+
+    const destAttr = attrGenerated.create([], {
+      namespace: sourceImpl._namespace,
+      prefix: sourceImpl._prefix,
+      localName: sourceImpl._localName,
+      value: sourceImpl._value
+    });
+
+    exports.appendAttribute(destElement, destAttr);
+  }
+};
+
+exports.attributeListsEqual = function (elementA, elementB) {
+  // Needed by https://dom.spec.whatwg.org/#concept-node-equals
+
+  const listA = elementA._attributes[INTERNAL].attributeList;
+  const listB = elementB._attributes[INTERNAL].attributeList;
+
+  if (listA.length !== listB.length) {
+    return false;
+  }
+
+  for (let i = 0; i < listA.length; ++i) {
+    const attrA = listA[i];
+    const implA = idlUtils.implForWrapper(attrA);
+
+    if (!listB.some(attrB => equalsA(attrB))) {
+      return false;
+    }
+
+    function equalsA(attrB) {
+      const implB = idlUtils.implForWrapper(attrB);
+
+      return implA._namespace === implB._namespace && implA._localName === implB._localName &&
+             implA._value === implB._value;
+    }
+  }
+
+  return true;
+};
+
+exports.hasAttributes = function (element) {
+  // Needed by https://dom.spec.whatwg.org/#dom-element-hasattributes
+
+  return element._attributes[INTERNAL].attributeList.length > 0;
+};

node_modules/jsdom/lib/jsdom/living/attributes/Attr-impl.js

@@ -0,0 +1,82 @@
+"use strict";
+
+exports.implementation = class AttrImpl {
+  constructor(_, 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.specified = true;
+  }
+
+  get namespaceURI() {
+    return this._namespace;
+  }
+
+  get prefix() {
+    return this._namespacePrefix;
+  }
+
+  get localName() {
+    return this._localName;
+  }
+
+  get name() {
+    return exports.getAttrImplQualifiedName(this);
+  }
+
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (this._element === null) {
+      this._value = v;
+    } else {
+      exports.changeAttributeImpl(this._element, this, v);
+    }
+  }
+
+  // Delegate to value
+  get nodeValue() {
+    return this.value;
+  }
+  set nodeValue(v) {
+    this.value = v;
+  }
+
+  // Delegate to value
+  get textContent() {
+    return this.value;
+  }
+  set textContent(v) {
+    this.value = v;
+  }
+
+  get ownerElement() {
+    return this._element;
+  }
+};
+
+exports.changeAttributeImpl = function (element, attributeImpl, value) {
+  // https://dom.spec.whatwg.org/#concept-element-attributes-change
+
+  // TODO mutation observer stuff
+
+  const oldValue = attributeImpl._value;
+  attributeImpl._value = value;
+
+  // Run jsdom hooks; roughly correspond to spec's "An attribute is set and an attribute is changed."
+  element._attrModified(exports.getAttrImplQualifiedName(attributeImpl), value, oldValue);
+};
+
+exports.getAttrImplQualifiedName = function (attributeImpl) {
+  // https://dom.spec.whatwg.org/#concept-attribute-qualified-name
+
+  if (attributeImpl._namespacePrefix === null) {
+    return attributeImpl._localName;
+  }
+
+  return attributeImpl._namespacePrefix + ":" + attributeImpl._localName;
+};

node_modules/jsdom/lib/jsdom/living/blob-symbols.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.buffer = Symbol("buffer");
+exports.type = Symbol("type");
+exports.lastModified = Symbol("lastModified");
+exports.closed = Symbol("closed");
+

node_modules/jsdom/lib/jsdom/living/blob.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const blobSymbols = require("./blob-symbols");
+
+class Blob {
+  constructor() {
+    if (!(this instanceof Blob)) {
+      throw new TypeError("DOM object constructor cannot be called as a function.");
+    }
+    const parts = arguments[0];
+    const properties = arguments[1];
+    if (arguments.length > 0) {
+      if (!parts || typeof parts !== "object" || parts instanceof Date || parts instanceof RegExp) {
+        throw new TypeError("Blob parts must be objects that are not Dates or RegExps");
+      }
+    }
+
+    const buffers = [];
+
+    if (parts) {
+      const l = Number(parts.length);
+      for (let i = 0; i < l; i++) {
+        const part = parts[i];
+        let buffer;
+        if (part instanceof ArrayBuffer) {
+          buffer = new Buffer(new Uint8Array(part));
+        } else if (part instanceof Blob) {
+          buffer = part[blobSymbols.buffer];
+        } else if (ArrayBuffer.isView(part)) {
+          buffer = new Buffer(new Uint8Array(part.buffer, part.byteOffset, part.byteLength));
+        } else {
+          buffer = new Buffer(typeof part === "string" ? part : String(part));
+        }
+        buffers.push(buffer);
+      }
+    }
+
+    this[blobSymbols.buffer] = Buffer.concat(buffers);
+
+    this[blobSymbols.type] = properties && properties.type ? String(properties.type).toLowerCase() : "";
+    if (!this[blobSymbols.type].match(/^ *[a-z0-9-]+(?:\/[a-z0-9-]+)? *(; *charset *= *[a-z0-9-]+ *)?$/)) {
+      this[blobSymbols.type] = "";
+    }
+    this[blobSymbols.lastModified] = properties && properties.lastModified ? properties.lastModified : null;
+    this[blobSymbols.closed] = false;
+  }
+  get size() {
+    return this[blobSymbols.buffer].length;
+  }
+  get type() {
+    return this[blobSymbols.type];
+  }
+  get lastModified() {
+    return this[blobSymbols.lastModified];
+  }
+  slice() {
+    const buffer = this[blobSymbols.buffer];
+    const slicedBuffer = buffer.slice(
+      arguments[0] || 0,
+      arguments[1] || this.size
+    );
+    const blob = new Blob([], { type: arguments[2] || this.type });
+    blob[blobSymbols.buffer] = slicedBuffer;
+    return blob;
+  }
+  close() {
+    this[blobSymbols.closed] = true;
+  }
+  toString() {
+    return "[object Blob]";
+  }
+}
+
+module.exports = function (core) {
+  core.Blob = Blob;
+};

node_modules/jsdom/lib/jsdom/living/character-data.js

@@ -0,0 +1,113 @@
+"use strict";
+const inheritFrom = require("../utils").inheritFrom;
+const domSymbolTree = require("./helpers/internal-constants").domSymbolTree;
+
+module.exports = function (core) {
+  core.CharacterData = function CharacterData(ownerDocument, data) {
+    core.Node.call(this, ownerDocument);
+
+    this._data = data;
+  };
+
+  inheritFrom(core.Node, core.CharacterData, {
+    get data() {
+      return this._data;
+    },
+    set data(data) {
+      if (data === null) {
+        data = "";
+      }
+      data = String(data);
+
+      this._setData(data);
+    },
+
+    get length() {
+      return this._data.length;
+    },
+
+    substringData(offset, count) {
+      if (arguments.length < 2) {
+        throw new TypeError("Not enough arguments to CharacterData.prototype.substringData");
+      }
+      offset >>>= 0;
+      count >>>= 0;
+
+      const length = this.length;
+
+      if (offset > length) {
+        throw new core.DOMException(core.DOMException.INDEX_SIZE_ERR);
+      }
+
+      if (offset + count > length) {
+        return this._data.substring(offset);
+      }
+
+      return this._data.substring(offset, offset + count);
+    },
+
+    appendData(data) {
+      if (arguments.length < 1) {
+        throw new TypeError("Not enough arguments to CharacterData.prototype.appendData");
+      }
+
+      this.replaceData(this.length, 0, data);
+    },
+
+    insertData(offset, data) {
+      if (arguments.length < 2) {
+        throw new TypeError("Not enough arguments to CharacterData.prototype.insertData");
+      }
+
+      this.replaceData(offset, 0, data);
+    },
+
+    deleteData(offset, count) {
+      if (arguments.length < 2) {
+        throw new TypeError("Not enough arguments to CharacterData.prototype.deleteData");
+      }
+
+      this.replaceData(offset, count, "");
+    },
+
+    replaceData(offset, count, data) {
+      if (arguments.length < 3) {
+        throw new TypeError("Not enough arguments to CharacterData.prototype.replaceData");
+      }
+      offset >>>= 0;
+      count >>>= 0;
+      data = String(data);
+
+      const length = this.length;
+
+      if (offset > length) {
+        throw new core.DOMException(core.DOMException.INDEX_SIZE_ERR);
+      }
+
+      if (offset + count > length) {
+        count = length - offset;
+      }
+
+      const start = this._data.substring(0, offset);
+      const end = this._data.substring(offset + count);
+
+      this._setData(start + data + end);
+
+      // TODO: range stuff
+    },
+
+    _setData(newData) {
+      // TODO: remove this once we no longer rely on mutation events internally, since they are nonstandard
+      const oldData = this._data;
+      this._data = newData;
+
+      if (this._ownerDocument &&
+          domSymbolTree.parent(this) &&
+          this._ownerDocument.implementation._hasFeature("MutationEvents")) {
+        const ev = this._ownerDocument.createEvent("MutationEvents");
+        ev.initMutationEvent("DOMCharacterDataModified", true, false, this, oldData, newData, null, null);
+        this.dispatchEvent(ev);
+      }
+    }
+  });
+};

node_modules/jsdom/lib/jsdom/living/comment.js

@@ -0,0 +1,14 @@
+"use strict";
+const inheritFrom = require("../utils").inheritFrom;
+const NODE_TYPE = require("../living/node-type");
+
+module.exports = function (core) {
+  // TODO: constructor should not take ownerDocument
+  core.Comment = function Comment(ownerDocument, data) {
+    core.CharacterData.call(this, ownerDocument, data);
+  };
+
+  inheritFrom(core.CharacterData, core.Comment, {
+    nodeType: NODE_TYPE.COMMENT_NODE // TODO should be on prototype, not here
+  });
+};

node_modules/jsdom/lib/jsdom/living/document-type.js

@@ -0,0 +1,47 @@
+"use strict";
+const NODE_TYPE = require("../living/node-type");
+
+const privates = Symbol("DocumentType internal slots");
+
+module.exports = core => {
+  core.DocumentType = class DocumentType extends core.Node {
+    constructor(secret, ownerDocument, name, publicId, systemId) {
+      if (secret !== privates) {
+        throw new TypeError("Invalid constructor");
+      }
+
+      super(ownerDocument);
+      this[privates] = { name, publicId, systemId };
+    }
+
+    get name() {
+      return this[privates].name;
+    }
+    get publicId() {
+      return this[privates].publicId;
+    }
+    get systemId() {
+      return this[privates].systemId;
+    }
+  };
+
+  core.DocumentType.prototype.nodeType = NODE_TYPE.DOCUMENT_TYPE_NODE; // TODO should be on Node, not here
+};
+
+module.exports.create = (core, ownerDocument, name, publicId, systemId) => {
+  return new core.DocumentType(privates, ownerDocument, name, publicId, systemId);
+};
+
+module.exports.clone = (core, otherDoctype) => {
+  return new core.DocumentType(
+    privates,
+    otherDoctype._ownerDocument,
+    otherDoctype[privates].name,
+    otherDoctype[privates].publicId,
+    otherDoctype[privates].systemId
+  );
+};
+
+module.exports.getPrivates = doctype => {
+  return doctype[privates];
+};

node_modules/jsdom/lib/jsdom/living/document.js

@@ -0,0 +1,162 @@
+"use strict";
+const DOMException = require("../web-idl/DOMException");
+const validateNames = require("./helpers/validate-names");
+const defineGetter = require("../utils").defineGetter;
+const defineSetter = require("../utils").defineSetter;
+const memoizeQuery = require("../utils").memoizeQuery;
+const generatedAttr = require("./generated/Attr");
+const clone = require("./node").clone;
+const listOfElementsWithClassNames = require("./node").listOfElementsWithClassNames;
+const validateName = require("./helpers/validate-names").name;
+const validateAndExtract = require("./helpers/validate-names").validateAndExtract;
+const NODE_TYPE = require("../living/node-type");
+
+module.exports = function (core) {
+  core.Document.prototype.createProcessingInstruction = function (target, data) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Document.prototype.createProcessingInstruction");
+    }
+    target = String(target);
+    data = String(data);
+
+    validateNames.name(target);
+
+    if (data.indexOf("?>") !== -1) {
+      throw new core.DOMException(core.DOMException.INVALID_CHARACTER_ERR,
+        "Processing instruction data cannot contain the string \"?>\"");
+    }
+
+    return new core.ProcessingInstruction(this._ownerDocument, target, data);
+  };
+
+  core.Document.prototype.createTextNode = function (data) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Document.prototype.createTextNode");
+    }
+    data = String(data);
+
+    return new core.Text(this, data);
+  };
+
+  core.Document.prototype.createComment = function (data) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Document.prototype.createComment");
+    }
+    data = String(data);
+
+    return new core.Comment(this, data);
+  };
+
+  core.Document.prototype.createElement = function (localName) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Document.prototype.createElement");
+    }
+    localName = String(localName);
+
+    validateName(localName);
+    if (this._parsingMode === "html") {
+      localName = localName.toLowerCase();
+    }
+
+    const element = this._createElementWithCorrectElementInterface(localName, "http://www.w3.org/1999/xhtml");
+    element._namespaceURI = "http://www.w3.org/1999/xhtml";
+    element._localName = localName;
+    element._ownerDocument = this;
+
+    return element;
+  };
+
+  core.Document.prototype.createElementNS = function (namespace, qualifiedName) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Document.prototype.createElementNS");
+    }
+    namespace = namespace !== null ? String(namespace) : namespace;
+    qualifiedName = String(qualifiedName);
+
+    const extracted = validateAndExtract(namespace, qualifiedName);
+
+    const element = this._createElementWithCorrectElementInterface(extracted.localName, extracted.namespace);
+    element._namespaceURI = extracted.namespace;
+    element._prefix = extracted.prefix;
+    element._localName = extracted.localName;
+    element._ownerDocument = this;
+
+    return element;
+  };
+
+  core.Document.prototype.createDocumentFragment = function () {
+    return new core.DocumentFragment(this);
+  };
+
+  core.Document.prototype.createAttribute = function (localName) {
+    if (arguments.length < 1) {
+      throw new TypeError("not enough arguments to Document.prototype.createAttribute");
+    }
+    localName = String(localName);
+
+    validateName(localName);
+
+    if (this._parsingMode === "html") {
+      localName = localName.toLowerCase();
+    }
+
+    return generatedAttr.create([], { localName });
+  };
+
+  core.Document.prototype.createAttributeNS = function (namespace, name) {
+    if (arguments.length < 2) {
+      throw new TypeError("not enough arguments to Document.prototype.createAttributeNS");
+    }
+    if (namespace === undefined) {
+      namespace = null;
+    }
+    namespace = namespace !== null ? String(namespace) : namespace;
+    name = String(name);
+
+    const extracted = validateAndExtract(namespace, name);
+    return generatedAttr.create([], {
+      namespace: extracted.namespace,
+      namespacePrefix: extracted.prefix,
+      localName: extracted.localName
+    });
+  };
+
+
+  core.Document.prototype.importNode = function (node, deep) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Document.prototype.createElement");
+    }
+    if (!("_ownerDocument" in node)) {
+      throw new TypeError("First argument to importNode must be a Node");
+    }
+    deep = Boolean(deep);
+
+    if (node.nodeType === NODE_TYPE.DOCUMENT_NODE) {
+      throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Cannot import a document node");
+    }
+
+    return clone(core, node, this, deep);
+  };
+
+  core.Document.prototype.getElementsByClassName = memoizeQuery(function getElementsByClassName(classNames) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Document.prototype.getElementsByClassName");
+    }
+
+    classNames = String(classNames);
+    return listOfElementsWithClassNames(classNames, this);
+  });
+
+  // https://html.spec.whatwg.org/multipage/dom.html#dom-document-cookie
+  defineGetter(core.Document.prototype, "cookie", function () {
+    return this._cookieJar.getCookieStringSync(this._URL, { http: false });
+  });
+
+  defineSetter(core.Document.prototype, "cookie", function (cookieStr) {
+    cookieStr = String(cookieStr);
+    this._cookieJar.setCookieSync(cookieStr, this._URL, {
+      http: false,
+      ignoreError: true
+    });
+  });
+};

node_modules/jsdom/lib/jsdom/living/dom-implementation.js

@@ -0,0 +1,90 @@
+"use strict";
+const validateNames = require("./helpers/validate-names");
+const createDocumentTypeInternal = require("./document-type").create;
+
+module.exports = function (core) {
+  core.DOMImplementation.prototype.hasFeature = function () {
+    return true;
+  };
+
+  core.DOMImplementation.prototype.createDocumentType = function (qualifiedName, publicId, systemId) {
+    if (arguments.length < 3) {
+      throw new TypeError("Expected 3 arguments to createDocumentType");
+    }
+
+    qualifiedName = String(qualifiedName);
+    publicId = String(publicId);
+    systemId = String(systemId);
+
+    validateNames.qname(qualifiedName);
+
+    return createDocumentTypeInternal(core, this._ownerDocument, qualifiedName, publicId, systemId);
+  };
+
+  core.DOMImplementation.prototype.createDocument = function (namespace, qualifiedName, doctype) {
+    namespace = namespace !== null ? String(namespace) : namespace;
+    qualifiedName = qualifiedName === null ? "" : String(qualifiedName);
+    if (doctype === undefined) {
+      doctype = null;
+    }
+
+    const document = new core.Document({ parsingMode: "xml" });
+
+    let element = null;
+    if (qualifiedName !== "") {
+      element = document.createElementNS(namespace, qualifiedName);
+    }
+
+    if (doctype !== null) {
+      document.appendChild(doctype);
+    }
+
+    if (element !== null) {
+      document.appendChild(element);
+    }
+
+    return document;
+  };
+
+  core.DOMImplementation.prototype.createHTMLDocument = function (title) {
+    // Let doc be a new document that is an HTML document.
+    // Set doc's content type to "text/html".
+    const document = new core.HTMLDocument({ parsingMode: "html" });
+
+    // 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 = createDocumentTypeInternal(core, this, "html", "", "");
+    document.appendChild(doctype);
+
+    // Create an html element in the HTML namespace, and append it to doc.
+    const htmlElement = document.createElementNS("http://www.w3.org/1999/xhtml", "html");
+    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 = document.createElement("head");
+    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 = document.createElement("title");
+      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.
+    htmlElement.appendChild(document.createElement("body"));
+
+    // 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;
+  };
+};

node_modules/jsdom/lib/jsdom/living/dom-token-list.js

@@ -0,0 +1,193 @@
+"use strict";
+
+const DOMException = require("../web-idl/DOMException");
+const orderedSetParser = require("./helpers/ordered-set-parser");
+
+// https://dom.spec.whatwg.org/#domtokenlist
+
+const INTERNAL = Symbol("DOMTokenList internal");
+
+class DOMTokenList {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+
+  item(index) {
+    const length = this.length;
+    return length <= index || index < 0 ? null : this[index];
+  }
+
+  contains(token) {
+    token = String(token);
+
+    validateToken(token);
+    return indexOf(this, token) !== -1;
+  }
+
+  add(/* tokens... */) {
+    for (let i = 0; i < arguments.length; i++) {
+      const token = String(arguments[i]);
+      validateToken(token);
+
+      if (indexOf(this, token) === -1) {
+        push(this, token);
+      }
+    }
+    update(this);
+  }
+
+  remove(/* tokens... */) {
+    for (let i = 0; i < arguments.length; i++) {
+      const token = String(arguments[i]);
+      validateToken(token);
+
+      const index = indexOf(this, token);
+      if (index !== -1) {
+        spliceLite(this, index, 1);
+      }
+    }
+    update(this);
+  }
+
+  // if force is true, this behaves like add
+  // if force is false, this behaves like remove
+  // if force is undefined, this behaves as one would expect toggle to
+  // always returns whether classList contains token after toggling
+  toggle(token, force) {
+    token = String(token);
+    force = force === undefined ? undefined : Boolean(force);
+
+    validateToken(token);
+
+    const index = indexOf(this, token);
+
+    if (index !== -1) {
+      if (force === false || force === undefined) {
+        spliceLite(this, index, 1);
+        update(this);
+        return false;
+      }
+
+      return true;
+    }
+
+    if (force === false) {
+      return false;
+    }
+
+    push(this, token);
+    update(this);
+    return true;
+  }
+
+  get length() {
+    return this[INTERNAL].tokens.length;
+  }
+
+  toString() {
+    return this[INTERNAL].tokens.join(" ");
+  }
+}
+
+function validateToken(token) {
+  if (token === "") {
+    throw new DOMException(DOMException.SYNTAX_ERR, "The token provided must not be empty.");
+  }
+
+  if (/\s/.test(token)) {
+    const whitespaceMsg = "The token provided contains HTML space characters, which are not valid in tokens.";
+    throw new DOMException(DOMException.INVALID_CHARACTER_ERR, whitespaceMsg);
+  }
+}
+
+function update(list) {
+  const attribute = list[INTERNAL].attribute;
+  if (attribute !== undefined) {
+    list[INTERNAL].element.setAttribute(attribute, list.toString());
+  }
+}
+
+// calls indexOf on internal array
+function indexOf(dtl, token) {
+  return dtl[INTERNAL].tokens.indexOf(token);
+}
+
+// calls push on internal array, then manually adds indexed property to dtl
+function push(dtl, token) {
+  const len = dtl[INTERNAL].tokens.push(token);
+  dtl[len - 1] = token;
+
+  return len;
+}
+
+// calls splice on internal array then rewrites indexed properties of dtl
+// does not allow items to be added, only removed, so splice-lite
+function spliceLite(dtl, start, deleteCount) {
+  const tokens = dtl[INTERNAL].tokens;
+  const removedTokens = tokens.splice(start, deleteCount);
+
+  // remove indexed properties from list
+  const re = /^\d+$/;
+
+  for (const prop in dtl) {
+    if (re.test(prop)) {
+      delete dtl[prop];
+    }
+  }
+
+  // copy indexed properties from internal array
+  const len = tokens.length;
+
+  for (let i = 0; i < len; i++) {
+    dtl[i] = tokens[i];
+  }
+
+  return removedTokens;
+}
+
+exports.DOMTokenList = DOMTokenList;
+
+// set dom token list without running update steps
+exports.reset = function resetDOMTokenList(list, value) {
+  const tokens = list[INTERNAL].tokens;
+
+  spliceLite(list, 0, tokens.length);
+  value = (value || "").trim();
+
+  if (value !== "") {
+    for (const token of orderedSetParser(value)) {
+      push(list, token);
+    }
+  }
+};
+
+exports.create = function createDOMTokenList(element, attribute) {
+  const list = Object.create(DOMTokenList.prototype);
+
+  list[INTERNAL] = {
+    element,
+    attribute,
+    tokens: []
+  };
+
+  exports.reset(list, element.getAttribute(attribute));
+
+  return list;
+};
+
+exports.contains = function domTokenListContains(list, token, options) {
+  const caseInsensitive = options && options.caseInsensitive;
+
+  if (!caseInsensitive) {
+    return indexOf(list, token) !== -1;
+  }
+
+  const tokens = list[INTERNAL].tokens;
+  const lowerToken = token.toLowerCase();
+  for (let i = 0; i < tokens.length; ++i) {
+    if (tokens[i].toLowerCase() === lowerToken) {
+      return true;
+    }
+  }
+  return false;
+};

node_modules/jsdom/lib/jsdom/living/element.js

@@ -0,0 +1,215 @@
+"use strict";
+const defineGetter = require("../utils").defineGetter;
+const memoizeQuery = require("../utils").memoizeQuery;
+const attributes = require("./attributes");
+const attrGenerated = require("./generated/Attr");
+const createDOMTokenList = require("./dom-token-list").create;
+const listOfElementsWithClassNames = require("./node").listOfElementsWithClassNames;
+const validateNames = require("./helpers/validate-names");
+const DOMException = require("../web-idl/DOMException");
+
+module.exports = function (core) {
+  defineGetter(core.Element, "attributes", function () {
+    return this._attributes;
+  });
+
+  defineGetter(core.Element.prototype, "classList", function () {
+    if (this._classList === undefined) {
+      this._classList = createDOMTokenList(this, "class");
+    }
+    return this._classList;
+  });
+
+  core.Element.prototype.hasAttributes = function hasAttributes() {
+    return attributes.hasAttributes(this);
+  };
+
+  core.Element.prototype.getAttribute = function getAttribute(name) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.getAttribute");
+    }
+    name = String(name);
+
+    return attributes.getAttributeValue(this, name);
+  };
+
+  core.Element.prototype.getAttributeNS = function getAttributeNS(namespace, localName) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Element.prototype.getAttributeNS");
+    }
+    if (namespace === undefined || namespace === null) {
+      namespace = null;
+    } else {
+      namespace = String(namespace);
+    }
+    localName = String(localName);
+
+    return attributes.getAttributeValueByNameNS(this, namespace, localName);
+  };
+
+  core.Element.prototype.setAttribute = function setAttribute(name, value) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Element.prototype.setAttribute");
+    }
+    name = String(name);
+    value = String(value);
+
+    validateNames.name(name);
+
+    if (this._namespaceURI === "http://www.w3.org/1999/xhtml" && this._ownerDocument._parsingMode === "html") {
+      name = name.toLowerCase();
+    }
+
+    const attribute = attributes.getAttributeByName(this, name);
+
+    if (attribute === null) {
+      const newAttr = attrGenerated.create([], { localName: name, value });
+      attributes.appendAttribute(this, newAttr);
+      return;
+    }
+
+    attributes.changeAttribute(this, attribute, value);
+  };
+
+  core.Element.prototype.setAttributeNS = function setAttributeNS(namespace, name, value) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Element.prototype.setAttributeNS");
+    }
+    if (namespace === undefined || namespace === null) {
+      namespace = null;
+    } else {
+      namespace = String(namespace);
+    }
+    name = String(name);
+    value = String(value);
+
+    const extracted = validateNames.validateAndExtract(namespace, name);
+
+    attributes.setAttributeValue(this, extracted.localName, value, extracted.prefix, extracted.namespace);
+  };
+
+  core.Element.prototype.removeAttribute = function removeAttribute(name) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.removeAttribute");
+    }
+    name = String(name);
+
+    attributes.removeAttributeByName(this, name);
+  };
+
+  core.Element.prototype.removeAttributeNS = function removeAttributeNS(namespace, localName) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Element.prototype.removeAttributeNS");
+    }
+    if (namespace === undefined || namespace === null) {
+      namespace = null;
+    } else {
+      namespace = String(namespace);
+    }
+    localName = String(localName);
+
+    attributes.removeAttributeByNameNS(this, namespace, localName);
+  };
+
+  core.Element.prototype.hasAttribute = function hasAttribute(name) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.hasAttribute");
+    }
+    name = String(name);
+
+    if (this._namespaceURI === "http://www.w3.org/1999/xhtml" && this._ownerDocument._parsingMode === "html") {
+      name = name.toLowerCase();
+    }
+
+    return attributes.hasAttributeByName(this, name);
+  };
+
+  core.Element.prototype.hasAttributeNS = function hasAttributeNS(namespace, localName) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Element.prototype.hasAttributeNS");
+    }
+    if (namespace === undefined || namespace === null) {
+      namespace = null;
+    } else {
+      namespace = String(namespace);
+    }
+    localName = String(localName);
+
+    if (namespace === "") {
+      namespace = null;
+    }
+
+    return attributes.hasAttributeByNameNS(this, namespace, localName);
+  };
+
+  core.Element.prototype.getAttributeNode = function getAttributeNode(name) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.getAttributeNode");
+    }
+    name = String(name);
+
+    return attributes.getAttributeByName(this, name);
+  };
+
+  core.Element.prototype.getAttributeNodeNS = function getAttributeNodeNS(namespace, localName) {
+    if (arguments.length < 2) {
+      throw new TypeError("Not enough arguments to Element.prototype.getAttributeNodeNS");
+    }
+    if (namespace === undefined || namespace === null) {
+      namespace = null;
+    } else {
+      namespace = String(namespace);
+    }
+    localName = String(localName);
+
+    return attributes.getAttributeByNameNS(this, namespace, localName);
+  };
+
+  core.Element.prototype.setAttributeNode = function setAttributeNode(attr) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.setAttributeNode");
+    }
+    if (!attrGenerated.is(attr)) {
+      throw new TypeError("First argument to Element.prototype.setAttributeNode must be an Attr");
+    }
+
+    return attributes.setAttribute(this, attr);
+  };
+
+  core.Element.prototype.setAttributeNodeNS = function setAttributeNodeNS(attr) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.setAttributeNodeNS");
+    }
+    if (!attrGenerated.is(attr)) {
+      throw new TypeError("First argument to Element.prototype.setAttributeNodeNS must be an Attr");
+    }
+
+    return attributes.setAttribute(this, attr);
+  };
+
+  core.Element.prototype.removeAttributeNode = function removeAttributeNode(attr) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.setAttributeNode");
+    }
+    if (!attrGenerated.is(attr)) {
+      throw new TypeError("First argument to Element.prototype.removeAttributeNode must be an Attr");
+    }
+
+    if (!attributes.hasAttribute(this, attr)) {
+      throw new DOMException(DOMException.NOT_FOUND_ERR, "Tried to remove an attribute that was not present");
+    }
+
+    attributes.removeAttribute(this, attr);
+
+    return attr;
+  };
+
+  core.Element.prototype.getElementsByClassName = memoizeQuery(function getElementsByClassName(classNames) {
+    if (arguments.length < 1) {
+      throw new TypeError("Not enough arguments to Element.prototype.getElementsByClassName");
+    }
+
+    classNames = String(classNames);
+    return listOfElementsWithClassNames(classNames, this);
+  });
+};

node_modules/jsdom/lib/jsdom/living/events/CustomEvent-impl.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+class CustomEventImpl extends EventImpl {
+  initCustomEvent(type, bubbles, cancelable, detail) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.detail = detail;
+  }
+}
+
+module.exports = {
+  implementation: CustomEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/ErrorEvent-impl.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+class ErrorEventImpl extends EventImpl {
+
+}
+
+module.exports = {
+  implementation: ErrorEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/Event-impl.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const EventInit = require("../generated/EventInit");
+
+class EventImpl {
+  constructor(args, privateData) {
+    const type = args[0]; // TODO: Replace with destructuring
+    const eventInitDict = args[1] || EventInit.convert(undefined);
+
+    if (type) {
+      this.type = type;
+      this._initializedFlag = true;
+    } else {
+      this.type = "";
+      this._initializedFlag = false;
+    }
+
+    const wrapper = privateData.wrapper;
+    for (const key in eventInitDict) {
+      if (key in wrapper) {
+        this[key] = eventInitDict[key];
+      }
+    }
+
+    this.target = null;
+    this.currentTarget = null;
+    this.eventPhase = 0;
+
+    this._stopPropagationFlag = false;
+    this._stopImmediatePropagationFlag = false;
+    this._canceledFlag = false;
+    this._dispatchFlag = false;
+
+    this.isTrusted = false;
+    this.timeStamp = Date.now();
+  }
+
+  get defaultPrevented() {
+    return this._canceledFlag;
+  }
+
+  stopPropagation() {
+    this._stopPropagationFlag = true;
+  }
+
+  stopImmediatePropagation() {
+    this._stopPropagationFlag = true;
+    this._stopImmediatePropagation = true;
+  }
+
+  preventDefault() {
+    if (this.cancelable) {
+      this._canceledFlag = true;
+    }
+  }
+
+  _initialize(type, bubbles, cancelable) {
+    if (type) {
+      this.type = type;
+      this._initializedFlag = true;
+    } else {
+      this.type = "";
+      this._initializedFlag = false;
+    }
+
+    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);
+  }
+}
+
+module.exports = {
+  implementation: EventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/EventTarget-impl.js

@@ -0,0 +1,244 @@
+"use strict";
+const DOMException = require("../../web-idl/DOMException");
+const reportException = require("../helpers/runtime-script-errors");
+const domSymbolTree = require("../helpers/internal-constants").domSymbolTree;
+const idlUtils = require("../generated/utils");
+
+const Event = require("../generated/Event").interface;
+
+class EventTargetImpl {
+  constructor() {
+    this._eventListeners = Object.create(null);
+  }
+
+  addEventListener(type, callback, capture) {
+    // webidl2js currently can't handle neither optional arguments nor callback interfaces
+    if (callback === undefined || callback === null) {
+      callback = null;
+    } else if (typeof callback === "object") {
+      callback = callback.handleEvent;
+    } else if (typeof callback !== "function") {
+      throw new TypeError("Only undefined, null, an object, or a function are allowed for the callback parameter");
+    }
+
+    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.capture === capture && listener.callback === callback) {
+        return;
+      }
+    }
+
+    this._eventListeners[type].push({
+      callback,
+      capture
+    });
+  }
+
+  removeEventListener(type, callback, capture) {
+    if (callback === undefined || callback === null) {
+      callback = null;
+    } else if (typeof callback === "object") {
+      callback = callback.handleEvent;
+    } else if (typeof callback !== "function") {
+      throw new TypeError("Only undefined, null, an object, or a function are allowed for the callback parameter");
+    }
+
+    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.capture === capture) {
+        this._eventListeners[type].splice(i, 1);
+        break;
+      }
+    }
+  }
+
+  dispatchEvent(event) {
+    if (!(event instanceof Event)) {
+      throw new TypeError("Argument to dispatchEvent must be an Event");
+    }
+
+    const eventImpl = idlUtils.implForWrapper(event);
+    if (eventImpl._dispatchFlag || !eventImpl._initializedFlag) {
+      throw new DOMException(DOMException.INVALID_STATE_ERR, "Tried to dispatch an uninitialized event");
+    }
+    if (event.eventPhase !== event.NONE) {
+      throw new DOMException(DOMException.INVALID_STATE_ERR, "Tried to dispatch a dispatching event");
+    }
+
+    eventImpl.isTrusted = false;
+
+    return this._dispatch(event);
+  }
+
+  _dispatch(event, targetOverride) {
+    const eventImpl = idlUtils.implForWrapper(event);
+    eventImpl._dispatchFlag = true;
+    eventImpl.target = targetOverride || idlUtils.wrapperForImpl(this);
+
+    const eventPath = [];
+    let targetParent = domSymbolTree.parent(eventImpl.target);
+    let target = eventImpl.target;
+    while (targetParent) {
+      eventPath.push(targetParent);
+      target = targetParent;
+      targetParent = domSymbolTree.parent(targetParent);
+    }
+    if (event.type !== "load" && target._defaultView) { // https://html.spec.whatwg.org/#events-and-the-window-object
+      eventPath.push(target._defaultView);
+    }
+
+    eventImpl.eventPhase = Event.CAPTURING_PHASE;
+    for (let i = eventPath.length - 1; i >= 0; --i) {
+      if (eventImpl._stopPropagationFlag) {
+        break;
+      }
+
+      const object = eventPath[i];
+      const objectImpl = idlUtils.implForWrapper(object);
+      const eventListeners = objectImpl._eventListeners[event.type];
+      invokeEventListeners(eventListeners, object, event);
+    }
+
+    eventImpl.eventPhase = Event.AT_TARGET;
+
+    if (!eventImpl._stopPropagationFlag) {
+      invokeInlineListeners(eventImpl.target, event);
+
+      if (this._eventListeners[event.type]) {
+        const eventListeners = this._eventListeners[event.type];
+        invokeEventListeners(eventListeners, eventImpl.target, event);
+      }
+    }
+
+    if (event.bubbles) {
+      eventImpl.eventPhase = Event.BUBBLING_PHASE;
+      for (let i = 0; i < eventPath.length; ++i) {
+        if (eventImpl._stopPropagationFlag) {
+          break;
+        }
+
+        const object = eventPath[i];
+        const objectImpl = idlUtils.implForWrapper(object);
+        const eventListeners = objectImpl._eventListeners[event.type];
+        invokeInlineListeners(object, event);
+        invokeEventListeners(eventListeners, object, event);
+      }
+    }
+
+    eventImpl._dispatchFlag = false;
+    eventImpl.eventPhase = Event.NONE;
+    eventImpl.currentTarget = null;
+    return !eventImpl._canceledFlag;
+  }
+}
+
+module.exports = {
+  implementation: EventTargetImpl
+};
+
+function invokeInlineListeners(object, event) {
+  const inlineListener = getListenerForInlineEventHandler(object, event.type);
+  if (inlineListener) {
+    const document = object._ownerDocument || object._document;
+
+    // Will be falsy for windows that have closed
+    if (document && (!object.nodeName || document.implementation._hasFeature("ProcessExternalResources", "script"))) {
+      invokeEventListeners([{ callback: inlineListener }], object, event);
+    }
+  }
+}
+
+function invokeEventListeners(listeners, target, event) {
+  const document = target._ownerDocument || target._document;
+  // Will be falsy for windows that have closed
+  if (!document) {
+    return;
+  }
+
+  const eventImpl = idlUtils.implForWrapper(event);
+  eventImpl.currentTarget = target;
+  if (!listeners) {
+    return;
+  }
+
+  const handlers = listeners.slice();
+  for (let i = 0; i < handlers.length; ++i) {
+    if (eventImpl._stopImmediatePropagationFlag) {
+      return;
+    }
+
+    const listener = handlers[i];
+    if (listeners.indexOf(listener) === -1 ||
+        (event.eventPhase === Event.CAPTURING_PHASE && !listener.capture) ||
+        (event.eventPhase === Event.BUBBLING_PHASE && listener.capture)) {
+      continue;
+    }
+
+    try {
+      listener.callback.call(eventImpl.currentTarget, event);
+    } catch (e) {
+      let window = null;
+      if (target._document) {
+        window = target;
+      } else if (target._ownerDocument) {
+        window = target._ownerDocument._defaultView;
+      }
+
+      if (window) {
+        reportException(window, e);
+      }
+      // Errors in window-less documents just get swallowed... can you think of anything better?
+    }
+  }
+}
+
+const wrappedListener = Symbol("inline event listener wrapper");
+
+function getListenerForInlineEventHandler(target, type) {
+  const callback = target["on" + type];
+
+  if (!callback) { // TODO event handlers: only check null
+    return null;
+  }
+
+  if (!callback[wrappedListener]) {
+    // https://html.spec.whatwg.org/multipage/webappapis.html#the-event-handler-processing-algorithm
+    callback[wrappedListener] = function (E) {
+      const isWindowError = E.constructor.name === "ErrorEvent" && type === "error"; // TODO branding
+
+      let returnValue;
+      if (isWindowError) {
+        returnValue = callback.call(E.currentTarget, E.message, E.filename, E.lineno, E.colno, E.error);
+      } else {
+        returnValue = callback.call(E.currentTarget, E);
+      }
+
+      if (type === "mouseover" || isWindowError) {
+        if (returnValue) {
+          E.preventDefault();
+        }
+      } else if (!returnValue) {
+        E.preventDefault();
+      }
+    };
+  }
+
+  return callback[wrappedListener];
+}

node_modules/jsdom/lib/jsdom/living/events/HashChangeEvent-impl.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+class HashChangeEventImpl extends EventImpl {
+
+}
+
+module.exports = {
+  implementation: HashChangeEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/KeyboardEvent-impl.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+class KeyboardEventImpl extends UIEventImpl {
+  initKeyboardEvent(type, bubbles, cancelable, view, key, location, modifiersList, repeat, locale) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, key);
+    this.location = location;
+    this.modifiersList = modifiersList;
+    this.repeat = repeat;
+    this.locale = locale;
+  }
+}
+
+module.exports = {
+  implementation: KeyboardEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/MessageEvent-impl.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+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;
+  }
+}
+
+module.exports = {
+  implementation: MessageEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/MouseEvent-impl.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+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;
+  }
+}
+
+module.exports = {
+  implementation: MouseEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/MutationEvent-impl.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+class MutationEventImpl extends EventImpl {
+  initMutationEvent(type, bubbles, cancelable, relatedNode, prevValue, newValue, attrName, attrChange) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.relatedNode = relatedNode;
+    this.prevValue = prevValue;
+    this.newValue = newValue;
+    this.attrName = attrName;
+    this.attrChange = attrChange;
+  }
+}
+
+module.exports = {
+  implementation: MutationEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/ProgressEvent-impl.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+class ProgressEventImpl extends EventImpl {
+
+}
+
+module.exports = {
+  implementation: ProgressEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/TouchEvent-impl.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+class TouchEventImpl extends UIEventImpl {
+
+}
+
+module.exports = {
+  implementation: TouchEventImpl
+};

node_modules/jsdom/lib/jsdom/living/events/UIEvent-impl.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+class UIEventImpl extends EventImpl {
+  initUIEvent(type, bubbles, cancelable, view, detail) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.view = view;
+    this.detail = detail;
+  }
+}
+
+module.exports = {
+  implementation: UIEventImpl
+};

node_modules/jsdom/lib/jsdom/living/file-reader.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const DOMException = require("../web-idl/DOMException");
+const EventTarget = require("./generated/EventTarget");
+const addConstants = require("../utils").addConstants;
+const blobSymbols = require("./blob-symbols");
+
+function FileReaderEventTarget() {
+  if (!(this instanceof FileReaderEventTarget)) {
+    throw new TypeError("DOM object constructor cannot be called as a function.");
+  }
+  EventTarget.setup(this);
+}
+
+FileReaderEventTarget.prototype = Object.create(EventTarget.interface.prototype);
+
+module.exports = function createFileReader(window) {
+  const ProgressEvent = window.ProgressEvent;
+
+  class FileReader extends FileReaderEventTarget {
+    constructor() {
+      super();
+      this.error = null;
+      this.readyState = FileReader.EMPTY;
+      this.result = null;
+      this.onloadstart = null;
+      this.onprogress = null;
+      this.onload = null;
+      this.onabort = null;
+      this.onerror = null;
+      this.onloadend = null;
+    }
+    readAsArrayBuffer(file) {
+      readFile(this, file, "buffer");
+    }
+    readAsBinaryString(file) {
+      readFile(this, file, "binary");
+    }
+    readAsDataURL(file) {
+      readFile(this, file, "dataUrl");
+    }
+    readAsText(file, encoding) {
+      readFile(this, file, "text", encoding);
+    }
+    abort() {
+      if (this.readyState === this.DONE || this.readyState === this.EMPTY) {
+        this.result = null;
+        return;
+      }
+      if (this.readyState === this.LOADING) {
+        this.readyState = this.DONE;
+      }
+      this.dispatchEvent(new ProgressEvent("abort"));
+      this.dispatchEvent(new ProgressEvent("loadend"));
+    }
+
+    get _ownerDocument() {
+      return window.document;
+    }
+  }
+
+  addConstants(FileReader, {
+    EMPTY: 0,
+    LOADING: 1,
+    DONE: 2
+  });
+
+  function readFile(self, file, format, encoding) {
+    if (self.readyState === self.LOADING) {
+      throw new DOMException(DOMException.INVALID_STATE_ERR);
+    }
+    if (file[blobSymbols.closed]) {
+      self.error = new DOMException(DOMException.INVALID_STATE_ERR);
+      self.dispatchEvent(new ProgressEvent("error"));
+    }
+
+    self.readyState = self.LOADING;
+    self.dispatchEvent(new ProgressEvent("loadstart"));
+
+    process.nextTick(() => {
+      let data = file[blobSymbols.buffer];
+      if (!data) {
+        data = new Buffer("");
+      }
+      self.dispatchEvent(new ProgressEvent("progress", {
+        lengthComputable: !isNaN(file.size),
+        total: file.size,
+        loaded: data.length
+      }));
+
+      process.nextTick(() => {
+        self.readyState = self.DONE;
+        switch (format) {
+          default:
+          case "buffer":
+            const ab = new ArrayBuffer(data.length);
+            const view = new Uint8Array(ab);
+            for (let i = 0; i < data.length; ++i) {
+              view[i] = data[i];
+            }
+            self.result = ab;
+            break;
+          case "binary":
+            self.result = data.toString("binary");
+            break;
+          case "dataUrl":
+            let dataUrl = "data:";
+            if (file.type) {
+              dataUrl += file.type + ";";
+            }
+            if (/text/i.test(file.type)) {
+              dataUrl += "charset=utf-8,";
+              dataUrl += data.toString("utf8");
+            } else {
+              dataUrl += "base64,";
+              dataUrl += data.toString("base64");
+            }
+            self.result = dataUrl;
+            break;
+          case "text":
+            if (encoding) {
+              encoding = encoding.toLowerCase();
+              if (encoding === "utf-16" || encoding === "utf16") {
+                encoding = "utf-16le";
+              }
+            } else {
+              encoding = "utf8";
+            }
+            self.result = data.toString(encoding);
+            break;
+        }
+
+        self.dispatchEvent(new ProgressEvent("load"));
+
+        process.nextTick(() => {
+          if (self.readyState !== self.LOADING) {
+            self.dispatchEvent(new ProgressEvent("loadend"));
+          }
+        });
+      });
+    });
+  }
+
+  return FileReader;
+};

node_modules/jsdom/lib/jsdom/living/file-symbols.js

@@ -0,0 +1,3 @@
+"use strict";
+
+exports.name = Symbol("name");

node_modules/jsdom/lib/jsdom/living/file.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const fileSymbols = require("./file-symbols");
+
+module.exports = function (core) {
+  const Blob = core.Blob;
+
+  class File extends Blob {
+    constructor(fileBits, fileName) {
+      super(fileBits, arguments[2]);
+      if (!(this instanceof File)) {
+        throw new TypeError("DOM object constructor cannot be called as a function.");
+      }
+      this[fileSymbols.name] = fileName.replace(/\//g, ":");
+    }
+    get name() {
+      return this[fileSymbols.name];
+    }
+  }
+  core.File = File;
+};

node_modules/jsdom/lib/jsdom/living/filelist-symbols.js

@@ -0,0 +1,3 @@
+"use strict";
+
+exports.list = Symbol("list");

node_modules/jsdom/lib/jsdom/living/filelist.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const filelistSymbols = require("./filelist-symbols");
+
+module.exports = function (core) {
+  class FileList {
+    constructor() {
+      if (!(this instanceof FileList)) {
+        throw new TypeError("DOM object constructor cannot be called as a function.");
+      }
+      this[filelistSymbols.list] = [];
+    }
+    item(index) {
+      return this[filelistSymbols.list][index] || null;
+    }
+    get length() {
+      return this[filelistSymbols.list].length;
+    }
+  }
+  core.FileList = FileList;
+};

node_modules/jsdom/lib/jsdom/living/form-data-symbols.js

@@ -0,0 +1,3 @@
+"use strict";
+
+exports.formData = Symbol("entries");

node_modules/jsdom/lib/jsdom/living/form-data.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const formDataSymbols = require("./form-data-symbols");
+
+module.exports = function (core) {
+  const Blob = core.Blob;
+  const File = core.File;
+
+  class FormData {
+    constructor(form) {
+      if (!(this instanceof FormData)) {
+        throw new TypeError("DOM object constructor cannot be called as a function.");
+      }
+      const entries = this[formDataSymbols.entries] = [];
+      if (form && form.elements) {
+        for (let i = 0; i < form.elements.length; i++) {
+          const el = form.elements[i];
+          if (el.type === "file") {
+            for (let j = 0; j < el.files.length; j++) {
+              entries.push({ name: el.name, value: el.files.item(j) });
+            }
+          } else {
+            entries.push({ name: el.name, value: el.value });
+          }
+        }
+      }
+    }
+    append(name, value, filename) {
+      if (value instanceof Blob) {
+        value = new File(
+          [value],
+          filename || value.name || "blob",
+          { type: value.type, lastModified: value.lastModified }
+        );
+      } else {
+        value = String(value);
+      }
+      const entries = this[formDataSymbols.entries];
+      entries.push({ name, value });
+    }
+    delete(name) {
+      this[formDataSymbols.entries] = this[formDataSymbols.entries].filter(entry => entry.name !== name);
+    }
+    get(name) {
+      return this[formDataSymbols.entries].find(entry => entry.name === name) || null;
+    }
+    getAll(name) {
+      return this[formDataSymbols.entries].filter(entry => entry.name === name).map(entry => entry.value);
+    }
+    has(name) {
+      return this[formDataSymbols.entries].findIndex(entry => entry.name === name) !== -1;
+    }
+    set(name, value, filename) {
+      if (value instanceof Blob) {
+        value = new File(
+          [value],
+          filename || value.name || "blob",
+          { type: value.type, lastModified: value.lastModified }
+        );
+      } else {
+        value = String(value);
+      }
+      const newEntry = { name, value };
+      const entries = this[formDataSymbols.entries];
+      const existing = entries.findIndex(entry => entry.name === name);
+      if (existing !== -1) {
+        entries[existing] = newEntry;
+        this[formDataSymbols.entries] = entries.filter((entry, index) => entry.name !== name || index === existing);
+      } else {
+        entries.push(newEntry);
+      }
+    }
+    toString() {
+      return "[object FormData]";
+    }
+  }
+
+  core.FormData = FormData;
+};

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

@@ -0,0 +1,118 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../attributes/Attr-impl.js");
+
+const impl = utils.implSymbol;
+
+function Attr() {
+  throw new TypeError("Illegal constructor");
+}
+Object.defineProperty(Attr.prototype, "namespaceURI", {
+  get() {
+    return this[impl].namespaceURI;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "prefix", {
+  get() {
+    return this[impl].prefix;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "localName", {
+  get() {
+    return this[impl].localName;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "name", {
+  get() {
+    return this[impl].name;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "value", {
+  get() {
+    return this[impl].value;
+  },
+  set(V) {
+    V = conversions["DOMString"](V);
+    this[impl].value = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "nodeValue", {
+  get() {
+    return this[impl].nodeValue;
+  },
+  set(V) {
+    V = conversions["DOMString"](V, { treatNullAsEmptyString: true });
+    this[impl].nodeValue = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "textContent", {
+  get() {
+    return this[impl].textContent;
+  },
+  set(V) {
+    V = conversions["DOMString"](V, { treatNullAsEmptyString: true });
+    this[impl].textContent = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "ownerElement", {
+  get() {
+    return this[impl].ownerElement;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Attr.prototype, "specified", {
+  get() {
+    return this[impl].specified;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(Attr.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: Attr,
+  expose: {
+    Window: { Attr: Attr }
+  }
+};
+

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

@@ -0,0 +1,77 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/CustomEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+const convertCustomEventInit = require("./CustomEventInit").convert;
+
+function CustomEvent(type) {
+  if (!this || this[impl] || !(this instanceof CustomEvent)) {
+    throw new TypeError("Failed to construct 'CustomEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'CustomEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertCustomEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+CustomEvent.prototype = Object.create(Event.interface.prototype);
+CustomEvent.prototype.constructor = CustomEvent;
+
+CustomEvent.prototype.initCustomEvent = function initCustomEvent(type, bubbles, cancelable, detail) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 4) {
+    throw new TypeError("Failed to execute 'initCustomEvent' on 'CustomEvent': 4 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 4; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  return this[impl].initCustomEvent.apply(this[impl], args);
+};
+Object.defineProperty(CustomEvent.prototype, "detail", {
+  get() {
+    return this[impl].detail;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(CustomEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: CustomEvent,
+  expose: {
+    Window: { CustomEvent: CustomEvent },
+    Worker: { CustomEvent: CustomEvent }
+  }
+};
+

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

@@ -0,0 +1,34 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "detail";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    } else {
+      ret[key] = null;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,92 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/ErrorEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+const convertErrorEventInit = require("./ErrorEventInit").convert;
+
+function ErrorEvent(type) {
+  if (!this || this[impl] || !(this instanceof ErrorEvent)) {
+    throw new TypeError("Failed to construct 'ErrorEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'ErrorEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertErrorEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+ErrorEvent.prototype = Object.create(Event.interface.prototype);
+ErrorEvent.prototype.constructor = ErrorEvent;
+Object.defineProperty(ErrorEvent.prototype, "message", {
+  get() {
+    return this[impl].message;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(ErrorEvent.prototype, "filename", {
+  get() {
+    return this[impl].filename;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(ErrorEvent.prototype, "lineno", {
+  get() {
+    return this[impl].lineno;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(ErrorEvent.prototype, "colno", {
+  get() {
+    return this[impl].colno;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(ErrorEvent.prototype, "error", {
+  get() {
+    return this[impl].error;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(ErrorEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: ErrorEvent,
+  expose: {
+    Window: { ErrorEvent: ErrorEvent },
+    Worker: { ErrorEvent: ErrorEvent }
+  }
+};
+

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

@@ -0,0 +1,56 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "colno";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long"](value);
+    }
+
+    key = "error";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    }
+
+    key = "filename";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    }
+
+    key = "lineno";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long"](value);
+    }
+
+    key = "message";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,208 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/Event-impl.js");
+
+const impl = utils.implSymbol;
+const convertEventInit = require("./EventInit").convert;
+
+function Event(type) {
+  if (!this || this[impl] || !(this instanceof Event)) {
+    throw new TypeError("Failed to construct 'Event': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'Event': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+
+Event.prototype.stopPropagation = function stopPropagation() {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 0; ++i) {
+    args[i] = arguments[i];
+  }
+  return this[impl].stopPropagation.apply(this[impl], args);
+};
+
+Event.prototype.stopImmediatePropagation = function stopImmediatePropagation() {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 0; ++i) {
+    args[i] = arguments[i];
+  }
+  return this[impl].stopImmediatePropagation.apply(this[impl], args);
+};
+
+Event.prototype.preventDefault = function preventDefault() {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 0; ++i) {
+    args[i] = arguments[i];
+  }
+  return this[impl].preventDefault.apply(this[impl], args);
+};
+
+Event.prototype.initEvent = function initEvent(type, bubbles, cancelable) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 3) {
+    throw new TypeError("Failed to execute 'initEvent' on 'Event': 3 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 3; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  return this[impl].initEvent.apply(this[impl], args);
+};
+Object.defineProperty(Event.prototype, "type", {
+  get() {
+    return this[impl].type;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event.prototype, "target", {
+  get() {
+    return this[impl].target;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event.prototype, "currentTarget", {
+  get() {
+    return this[impl].currentTarget;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event, "NONE", {
+  value: 0,
+  enumerable: true
+});
+Object.defineProperty(Event.prototype, "NONE", {
+  value: 0,
+  enumerable: true
+});
+
+Object.defineProperty(Event, "CAPTURING_PHASE", {
+  value: 1,
+  enumerable: true
+});
+Object.defineProperty(Event.prototype, "CAPTURING_PHASE", {
+  value: 1,
+  enumerable: true
+});
+
+Object.defineProperty(Event, "AT_TARGET", {
+  value: 2,
+  enumerable: true
+});
+Object.defineProperty(Event.prototype, "AT_TARGET", {
+  value: 2,
+  enumerable: true
+});
+
+Object.defineProperty(Event, "BUBBLING_PHASE", {
+  value: 3,
+  enumerable: true
+});
+Object.defineProperty(Event.prototype, "BUBBLING_PHASE", {
+  value: 3,
+  enumerable: true
+});
+
+Object.defineProperty(Event.prototype, "eventPhase", {
+  get() {
+    return this[impl].eventPhase;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event.prototype, "bubbles", {
+  get() {
+    return this[impl].bubbles;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event.prototype, "cancelable", {
+  get() {
+    return this[impl].cancelable;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event.prototype, "defaultPrevented", {
+  get() {
+    return this[impl].defaultPrevented;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(Event.prototype, "timeStamp", {
+  get() {
+    return this[impl].timeStamp;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(Event.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    Object.defineProperty(obj, "isTrusted", {
+      get() {
+        return obj[impl].isTrusted;
+      },
+      enumerable: true,
+      configurable: false
+    });
+    
+    
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: Event,
+  expose: {
+    Window: { Event: Event },
+    Worker: { Event: Event }
+  }
+};
+

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

@@ -0,0 +1,40 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+
+module.exports = {
+  convertInherit(obj, ret) {
+    let key, value;
+
+    key = "bubbles";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "cancelable";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,146 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const UIEventInit = require("./UIEventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    UIEventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "altKey";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "ctrlKey";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "metaKey";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierAltGraph";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierCapsLock";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierFn";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierFnLock";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierHyper";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierNumLock";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierOS";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierScrollLock";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierSuper";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierSymbol";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "modifierSymbolLock";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "shiftKey";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,85 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/EventTarget-impl.js");
+
+const impl = utils.implSymbol;
+
+function EventTarget() {
+  throw new TypeError("Illegal constructor");
+}
+
+EventTarget.prototype.addEventListener = function addEventListener(type, callback) {
+  if (!this || !module.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 = [];
+  for (let i = 0; i < arguments.length && i < 3; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  if (args[2] !== undefined) {
+  args[2] = conversions["boolean"](args[2]);
+  }
+  return this[impl].addEventListener.apply(this[impl], args);
+};
+
+EventTarget.prototype.removeEventListener = function removeEventListener(type, callback) {
+  if (!this || !module.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 = [];
+  for (let i = 0; i < arguments.length && i < 3; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  if (args[2] !== undefined) {
+  args[2] = conversions["boolean"](args[2]);
+  }
+  return this[impl].removeEventListener.apply(this[impl], args);
+};
+
+EventTarget.prototype.dispatchEvent = function dispatchEvent(event) {
+  if (!this || !module.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 = [];
+  for (let i = 0; i < arguments.length && i < 1; ++i) {
+    args[i] = arguments[i];
+  }
+  return this[impl].dispatchEvent.apply(this[impl], args);
+};
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(EventTarget.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: EventTarget,
+  expose: {
+    Window: { EventTarget: EventTarget },
+    Worker: { EventTarget: EventTarget }
+  }
+};
+

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

@@ -0,0 +1,45 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../elements/HTMLTemplateElement-impl.js");
+
+const HTMLElement = require("./HTMLElement.js");
+const impl = utils.implSymbol;
+
+function HTMLTemplateElement() {
+  throw new TypeError("Illegal constructor");
+}
+HTMLTemplateElement.prototype = Object.create(HTMLElement.interface.prototype);
+HTMLTemplateElement.prototype.constructor = HTMLTemplateElement;
+Object.defineProperty(HTMLTemplateElement.prototype, "content", {
+  get() {
+    return this[impl].content;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(HTMLTemplateElement.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: HTMLTemplateElement,
+  expose: {
+    Window: { HTMLTemplateElement: HTMLTemplateElement }
+  }
+};
+

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

@@ -0,0 +1,68 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/HashChangeEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+const convertHashChangeEventInit = require("./HashChangeEventInit").convert;
+
+function HashChangeEvent(type) {
+  if (!this || this[impl] || !(this instanceof HashChangeEvent)) {
+    throw new TypeError("Failed to construct 'HashChangeEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'HashChangeEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertHashChangeEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+HashChangeEvent.prototype = Object.create(Event.interface.prototype);
+HashChangeEvent.prototype.constructor = HashChangeEvent;
+Object.defineProperty(HashChangeEvent.prototype, "oldURL", {
+  get() {
+    return this[impl].oldURL;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(HashChangeEvent.prototype, "newURL", {
+  get() {
+    return this[impl].newURL;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(HashChangeEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: HashChangeEvent,
+  expose: {
+    Window: { HashChangeEvent: HashChangeEvent },
+    Worker: { HashChangeEvent: HashChangeEvent }
+  }
+};
+

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

@@ -0,0 +1,38 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "newURL";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    }
+
+    key = "oldURL";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,220 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/KeyboardEvent-impl.js");
+
+const UIEvent = require("./UIEvent.js");
+const impl = utils.implSymbol;
+const convertKeyboardEventInit = require("./KeyboardEventInit").convert;
+
+function KeyboardEvent(typeArg) {
+  if (!this || this[impl] || !(this instanceof KeyboardEvent)) {
+    throw new TypeError("Failed to construct 'KeyboardEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'KeyboardEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertKeyboardEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+KeyboardEvent.prototype = Object.create(UIEvent.interface.prototype);
+KeyboardEvent.prototype.constructor = KeyboardEvent;
+
+KeyboardEvent.prototype.getModifierState = function getModifierState(keyArg) {
+  if (!this || !module.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 = [];
+  for (let i = 0; i < arguments.length && i < 1; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  return this[impl].getModifierState.apply(this[impl], args);
+};
+
+KeyboardEvent.prototype.initKeyboardEvent = function initKeyboardEvent(typeArg, bubblesArg, cancelableArg, viewArg, keyArg, locationArg, modifiersListArg, repeat, locale) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 9) {
+    throw new TypeError("Failed to execute 'initKeyboardEvent' on 'KeyboardEvent': 9 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 9; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  args[4] = conversions["DOMString"](args[4]);
+  args[5] = conversions["unsigned long"](args[5]);
+  args[6] = conversions["DOMString"](args[6]);
+  args[7] = conversions["boolean"](args[7]);
+  args[8] = conversions["DOMString"](args[8]);
+  return this[impl].initKeyboardEvent.apply(this[impl], args);
+};
+Object.defineProperty(KeyboardEvent, "DOM_KEY_LOCATION_STANDARD", {
+  value: 0,
+  enumerable: true
+});
+Object.defineProperty(KeyboardEvent.prototype, "DOM_KEY_LOCATION_STANDARD", {
+  value: 0,
+  enumerable: true
+});
+
+Object.defineProperty(KeyboardEvent, "DOM_KEY_LOCATION_LEFT", {
+  value: 1,
+  enumerable: true
+});
+Object.defineProperty(KeyboardEvent.prototype, "DOM_KEY_LOCATION_LEFT", {
+  value: 1,
+  enumerable: true
+});
+
+Object.defineProperty(KeyboardEvent, "DOM_KEY_LOCATION_RIGHT", {
+  value: 2,
+  enumerable: true
+});
+Object.defineProperty(KeyboardEvent.prototype, "DOM_KEY_LOCATION_RIGHT", {
+  value: 2,
+  enumerable: true
+});
+
+Object.defineProperty(KeyboardEvent, "DOM_KEY_LOCATION_NUMPAD", {
+  value: 3,
+  enumerable: true
+});
+Object.defineProperty(KeyboardEvent.prototype, "DOM_KEY_LOCATION_NUMPAD", {
+  value: 3,
+  enumerable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "key", {
+  get() {
+    return this[impl].key;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "code", {
+  get() {
+    return this[impl].code;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "location", {
+  get() {
+    return this[impl].location;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "ctrlKey", {
+  get() {
+    return this[impl].ctrlKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "shiftKey", {
+  get() {
+    return this[impl].shiftKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "altKey", {
+  get() {
+    return this[impl].altKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "metaKey", {
+  get() {
+    return this[impl].metaKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "repeat", {
+  get() {
+    return this[impl].repeat;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "isComposing", {
+  get() {
+    return this[impl].isComposing;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "charCode", {
+  get() {
+    return this[impl].charCode;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "keyCode", {
+  get() {
+    return this[impl].keyCode;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(KeyboardEvent.prototype, "which", {
+  get() {
+    return this[impl].which;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(KeyboardEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: KeyboardEvent,
+  expose: {
+    Window: { KeyboardEvent: KeyboardEvent }
+  }
+};
+

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

@@ -0,0 +1,90 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventModifierInit = require("./EventModifierInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventModifierInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "charCode";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "code";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    } else {
+      ret[key] = "";
+    }
+
+    key = "isComposing";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "key";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    } else {
+      ret[key] = "";
+    }
+
+    key = "keyCode";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "location";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "repeat";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "which";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long"](value);
+    } else {
+      ret[key] = 0;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,111 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/MessageEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+const convertMessageEventInit = require("./MessageEventInit").convert;
+
+function MessageEvent(type) {
+  if (!this || this[impl] || !(this instanceof MessageEvent)) {
+    throw new TypeError("Failed to construct 'MessageEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'MessageEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertMessageEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+MessageEvent.prototype = Object.create(Event.interface.prototype);
+MessageEvent.prototype.constructor = MessageEvent;
+
+MessageEvent.prototype.initMessageEvent = function initMessageEvent(type, bubbles, cancelable, data, origin, lastEventId, source, ports) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 8) {
+    throw new TypeError("Failed to execute 'initMessageEvent' on 'MessageEvent': 8 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 8; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  args[4] = conversions["DOMString"](args[4]);
+  args[5] = conversions["DOMString"](args[5]);
+  return this[impl].initMessageEvent.apply(this[impl], args);
+};
+Object.defineProperty(MessageEvent.prototype, "data", {
+  get() {
+    return this[impl].data;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MessageEvent.prototype, "origin", {
+  get() {
+    return this[impl].origin;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MessageEvent.prototype, "lastEventId", {
+  get() {
+    return this[impl].lastEventId;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MessageEvent.prototype, "source", {
+  get() {
+    return this[impl].source;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MessageEvent.prototype, "ports", {
+  get() {
+    return this[impl].ports;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(MessageEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: MessageEvent,
+  expose: {
+    Window: { MessageEvent: MessageEvent },
+    Worker: { MessageEvent: MessageEvent }
+  }
+};
+

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

@@ -0,0 +1,56 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "data";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    }
+
+    key = "lastEventId";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    }
+
+    key = "origin";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["DOMString"](value);
+    }
+
+    key = "ports";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    }
+
+    key = "source";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,181 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/MouseEvent-impl.js");
+
+const UIEvent = require("./UIEvent.js");
+const impl = utils.implSymbol;
+const convertMouseEventInit = require("./MouseEventInit").convert;
+
+function MouseEvent(typeArg) {
+  if (!this || this[impl] || !(this instanceof MouseEvent)) {
+    throw new TypeError("Failed to construct 'MouseEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'MouseEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertMouseEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+MouseEvent.prototype = Object.create(UIEvent.interface.prototype);
+MouseEvent.prototype.constructor = MouseEvent;
+
+MouseEvent.prototype.getModifierState = function getModifierState(keyArg) {
+  if (!this || !module.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 = [];
+  for (let i = 0; i < arguments.length && i < 1; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  return this[impl].getModifierState.apply(this[impl], args);
+};
+
+MouseEvent.prototype.initMouseEvent = function initMouseEvent(typeArg, bubblesArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 15) {
+    throw new TypeError("Failed to execute 'initMouseEvent' on 'MouseEvent': 15 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 15; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  args[4] = conversions["long"](args[4]);
+  args[5] = conversions["long"](args[5]);
+  args[6] = conversions["long"](args[6]);
+  args[7] = conversions["long"](args[7]);
+  args[8] = conversions["long"](args[8]);
+  args[9] = conversions["boolean"](args[9]);
+  args[10] = conversions["boolean"](args[10]);
+  args[11] = conversions["boolean"](args[11]);
+  args[12] = conversions["boolean"](args[12]);
+  args[13] = conversions["short"](args[13]);
+  return this[impl].initMouseEvent.apply(this[impl], args);
+};
+Object.defineProperty(MouseEvent.prototype, "screenX", {
+  get() {
+    return this[impl].screenX;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "screenY", {
+  get() {
+    return this[impl].screenY;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "clientX", {
+  get() {
+    return this[impl].clientX;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "clientY", {
+  get() {
+    return this[impl].clientY;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "ctrlKey", {
+  get() {
+    return this[impl].ctrlKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "shiftKey", {
+  get() {
+    return this[impl].shiftKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "altKey", {
+  get() {
+    return this[impl].altKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "metaKey", {
+  get() {
+    return this[impl].metaKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "button", {
+  get() {
+    return this[impl].button;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "relatedTarget", {
+  get() {
+    return this[impl].relatedTarget;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MouseEvent.prototype, "buttons", {
+  get() {
+    return this[impl].buttons;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(MouseEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: MouseEvent,
+  expose: {
+    Window: { MouseEvent: MouseEvent }
+  }
+};
+

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

@@ -0,0 +1,82 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventModifierInit = require("./EventModifierInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventModifierInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "button";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["short"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "buttons";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned short"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "clientX";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "clientY";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "relatedTarget";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    } else {
+      ret[key] = null;
+    }
+
+    key = "screenX";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "screenY";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["long"](value);
+    } else {
+      ret[key] = 0;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,125 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/MutationEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+
+function MutationEvent() {
+  throw new TypeError("Illegal constructor");
+}
+MutationEvent.prototype = Object.create(Event.interface.prototype);
+MutationEvent.prototype.constructor = MutationEvent;
+
+MutationEvent.prototype.initMutationEvent = function initMutationEvent(typeArg, bubblesArg, cancelableArg, relatedNodeArg, prevValueArg, newValueArg, attrNameArg, attrChangeArg) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 8) {
+    throw new TypeError("Failed to execute 'initMutationEvent' on 'MutationEvent': 8 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 8; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  args[4] = conversions["DOMString"](args[4]);
+  args[5] = conversions["DOMString"](args[5]);
+  args[6] = conversions["DOMString"](args[6]);
+  args[7] = conversions["unsigned short"](args[7]);
+  return this[impl].initMutationEvent.apply(this[impl], args);
+};
+Object.defineProperty(MutationEvent, "MODIFICATION", {
+  value: 1,
+  enumerable: true
+});
+Object.defineProperty(MutationEvent.prototype, "MODIFICATION", {
+  value: 1,
+  enumerable: true
+});
+
+Object.defineProperty(MutationEvent, "ADDITION", {
+  value: 2,
+  enumerable: true
+});
+Object.defineProperty(MutationEvent.prototype, "ADDITION", {
+  value: 2,
+  enumerable: true
+});
+
+Object.defineProperty(MutationEvent, "REMOVAL", {
+  value: 3,
+  enumerable: true
+});
+Object.defineProperty(MutationEvent.prototype, "REMOVAL", {
+  value: 3,
+  enumerable: true
+});
+
+Object.defineProperty(MutationEvent.prototype, "relatedNode", {
+  get() {
+    return this[impl].relatedNode;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MutationEvent.prototype, "prevValue", {
+  get() {
+    return this[impl].prevValue;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MutationEvent.prototype, "newValue", {
+  get() {
+    return this[impl].newValue;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MutationEvent.prototype, "attrName", {
+  get() {
+    return this[impl].attrName;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(MutationEvent.prototype, "attrChange", {
+  get() {
+    return this[impl].attrChange;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(MutationEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: MutationEvent,
+  expose: {
+    Window: { MutationEvent: MutationEvent }
+  }
+};
+

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

@@ -0,0 +1,77 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/ProgressEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+const convertProgressEventInit = require("./ProgressEventInit").convert;
+
+function ProgressEvent(type) {
+  if (!this || this[impl] || !(this instanceof ProgressEvent)) {
+    throw new TypeError("Failed to construct 'ProgressEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'ProgressEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertProgressEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+ProgressEvent.prototype = Object.create(Event.interface.prototype);
+ProgressEvent.prototype.constructor = ProgressEvent;
+Object.defineProperty(ProgressEvent.prototype, "lengthComputable", {
+  get() {
+    return this[impl].lengthComputable;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(ProgressEvent.prototype, "loaded", {
+  get() {
+    return this[impl].loaded;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(ProgressEvent.prototype, "total", {
+  get() {
+    return this[impl].total;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(ProgressEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: ProgressEvent,
+  expose: {
+    Window: { ProgressEvent: ProgressEvent },
+    DedicatedWorker: { ProgressEvent: ProgressEvent },
+    SharedWorker: { ProgressEvent: ProgressEvent }
+  }
+};
+

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

@@ -0,0 +1,50 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "lengthComputable";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["boolean"](value);
+    } else {
+      ret[key] = false;
+    }
+
+    key = "loaded";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "total";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["unsigned long long"](value);
+    } else {
+      ret[key] = 0;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

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

@@ -0,0 +1,93 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/TouchEvent-impl.js");
+
+const UIEvent = require("./UIEvent.js");
+const impl = utils.implSymbol;
+
+function TouchEvent() {
+  throw new TypeError("Illegal constructor");
+}
+TouchEvent.prototype = Object.create(UIEvent.interface.prototype);
+TouchEvent.prototype.constructor = TouchEvent;
+Object.defineProperty(TouchEvent.prototype, "touches", {
+  get() {
+    return this[impl].touches;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(TouchEvent.prototype, "targetTouches", {
+  get() {
+    return this[impl].targetTouches;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(TouchEvent.prototype, "changedTouches", {
+  get() {
+    return this[impl].changedTouches;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(TouchEvent.prototype, "altKey", {
+  get() {
+    return this[impl].altKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(TouchEvent.prototype, "metaKey", {
+  get() {
+    return this[impl].metaKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(TouchEvent.prototype, "ctrlKey", {
+  get() {
+    return this[impl].ctrlKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(TouchEvent.prototype, "shiftKey", {
+  get() {
+    return this[impl].shiftKey;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(TouchEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: TouchEvent,
+  expose: {
+    Window: { TouchEvent: TouchEvent }
+  }
+};
+

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

@@ -0,0 +1,85 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require("../events/UIEvent-impl.js");
+
+const Event = require("./Event.js");
+const impl = utils.implSymbol;
+const convertUIEventInit = require("./UIEventInit").convert;
+
+function UIEvent(type) {
+  if (!this || this[impl] || !(this instanceof UIEvent)) {
+    throw new TypeError("Failed to construct 'UIEvent': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'UIEvent': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = convertUIEventInit(args[1]);
+
+  module.exports.setup(this, args);
+}
+UIEvent.prototype = Object.create(Event.interface.prototype);
+UIEvent.prototype.constructor = UIEvent;
+
+UIEvent.prototype.initUIEvent = function initUIEvent(typeArg, bubblesArg, cancelableArg, viewArg, detailArg) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 5) {
+    throw new TypeError("Failed to execute 'initUIEvent' on 'UIEvent': 5 arguments required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 5; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["DOMString"](args[0]);
+  args[1] = conversions["boolean"](args[1]);
+  args[2] = conversions["boolean"](args[2]);
+  args[4] = conversions["long"](args[4]);
+  return this[impl].initUIEvent.apply(this[impl], args);
+};
+Object.defineProperty(UIEvent.prototype, "view", {
+  get() {
+    return this[impl].view;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(UIEvent.prototype, "detail", {
+  get() {
+    return this[impl].detail;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(UIEvent.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: UIEvent,
+  expose: {
+    Window: { UIEvent: UIEvent }
+  }
+};
+

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

@@ -0,0 +1,42 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit");
+
+module.exports = {
+  convertInherit(obj, ret) {
+    EventInit.convertInherit(obj, ret);
+    let key, value;
+
+    key = "detail";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = conversions["long"](value);
+    } else {
+      ret[key] = 0;
+    }
+
+    key = "view";
+    value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      ret[key] = (value);
+    } else {
+      ret[key] = null;
+    }
+  },
+
+  convert(obj) {
+    if (obj !== undefined && typeof obj !== "object") {
+      throw new TypeError("Dictionary has to be an object");
+    }
+    if (obj instanceof Date || obj instanceof RegExp) {
+      throw new TypeError("Dictionary may not be a Date or RegExp object");
+    }
+
+    const ret = Object.create(null);
+    module.exports.convertInherit(obj, ret);
+    return ret;
+  }
+};

node_modules/jsdom/lib/jsdom/living/generated/idl-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+
+module.exports.mixin = function mixin(target, source) {
+  const keys = Object.getOwnPropertyNames(source);
+  for (let i = 0; i < keys.length; ++i) {
+    Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
+  }
+};
+
+module.exports.wrapperSymbol = Symbol("wrapper");
+module.exports.implSymbol = Symbol("impl");
+
+module.exports.wrapperForImpl = function (impl) {
+  return impl[module.exports.wrapperSymbol];
+};
+
+module.exports.implForWrapper = function (wrapper) {
+  return wrapper[module.exports.implSymbol];
+};
+

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

@@ -0,0 +1,20 @@
+"use strict";
+
+module.exports.mixin = function mixin(target, source) {
+  const keys = Object.getOwnPropertyNames(source);
+  for (let i = 0; i < keys.length; ++i) {
+    Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
+  }
+};
+
+module.exports.wrapperSymbol = Symbol("wrapper");
+module.exports.implSymbol = Symbol("impl");
+
+module.exports.wrapperForImpl = function (impl) {
+  return impl[module.exports.wrapperSymbol];
+};
+
+module.exports.implForWrapper = function (wrapper) {
+  return wrapper[module.exports.implSymbol];
+};
+

node_modules/jsdom/lib/jsdom/living/helpers/document-base-url.js

@@ -0,0 +1,43 @@
+"use strict";
+const internalQuerySelector = require("../selectors").querySelector;
+const internalGetAttr = require("../attributes").getAttributeValue;
+const URL = require("../../utils").URL;
+
+exports.documentBaseURL = function (document) {
+  // https://html.spec.whatwg.org/multipage/infrastructure.html#document-base-url
+
+  const firstBase = internalQuerySelector(document, "base[href]");
+  const fallbackBaseURL = exports.fallbackBaseURL(document);
+
+  if (firstBase === null) {
+    return fallbackBaseURL;
+  }
+
+  return exports.frozenBaseURL(firstBase, fallbackBaseURL);
+};
+
+exports.fallbackBaseURL = function (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 module.exports.documentBaseURL(document._defaultView._parent._document);
+  }
+
+  return document._URL;
+};
+
+exports.frozenBaseURL = function (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 = internalGetAttr(baseElement, "href");
+
+  try {
+    return new URL(baseHrefAttribute, fallbackBaseURL).href;
+  } catch (e) {
+    return fallbackBaseURL;
+  }
+};

node_modules/jsdom/lib/jsdom/living/helpers/internal-constants.js

@@ -0,0 +1,17 @@
+"use strict";
+const SymbolTree = require("symbol-tree");
+
+exports.cloningSteps = Symbol("cloning steps");
+exports.locationInfo = Symbol("location info");
+exports.accept = Symbol("accept");
+exports.requestManager = Symbol("request manager");
+exports.pool = Symbol("pool");
+exports.agentOptions = Symbol("agentOptions");
+
+// 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");

node_modules/jsdom/lib/jsdom/living/helpers/ordered-set-parser.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function orderedSetParser(input) {
+  return new Set(input.split(/\s+/).filter(Boolean));
+};

node_modules/jsdom/lib/jsdom/living/helpers/proxied-window-event-handlers.js

@@ -0,0 +1,11 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#event-handlers-on-elements,-document-objects,-and-window-objects
+
+module.exports = new Set(["onblur", "onerror", "onfocus", "onload", "onresize", "onscroll", "onafterprint",
+  "onbeforeprint", "onbeforeunload", "onhashchange", "onlanguagechange", "onmessage", "onoffline", "ononline",
+  "onpagehide", "onpageshow", "onpopstate", "onstorage", "onunload"]);
+
+// level2/html sets up setters/getters on HTMLBodyElement that proxy to the window (setting data properties there)
+// level1/core sets up so that modifying the appropriate attributes on body elements will forward to setting on
+// the window, with the appropriate `this`.

node_modules/jsdom/lib/jsdom/living/helpers/runtime-script-errors.js

@@ -0,0 +1,61 @@
+"use strict";
+const util = require("util");
+const ErrorEvent = require("../generated/ErrorEvent").interface;
+
+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 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 (errorReportingMode in target) {
+    return false;
+  }
+
+  target[errorReportingMode] = true;
+
+  // TODO Events: use constructor directly, once they are no longer tied to a window.
+  const event = new ErrorEvent("error", {
+    bubbles: false,
+    cancelable: true,
+    message,
+    filename: location,
+    lineno: line,
+    colno: col,
+    error: errorObject
+  });
+
+  target.dispatchEvent(event);
+
+  delete target[errorReportingMode];
+
+  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 handled = reportAnError(lineNumber, columnNumber, window, error, error.message, fileName);
+
+  if (!handled) {
+    const jsdomError = new Error(`Uncaught ${util.inspect(error)}`);
+    jsdomError.detail = error;
+
+    window._virtualConsole.emit("jsdomError", jsdomError);
+  }
+};

node_modules/jsdom/lib/jsdom/living/helpers/validate-names.js

@@ -0,0 +1,62 @@
+"use strict";
+const xnv = require("xml-name-validator");
+const DOMException = require("../../web-idl/DOMException");
+
+// https://dom.spec.whatwg.org/#validate
+
+exports.name = function (name) {
+  const result = xnv.name(name);
+  if (!result.success) {
+    throw new DOMException(DOMException.INVALID_CHARACTER_ERR,
+      "\"" + name + "\" did not match the Name production: " + result.error);
+  }
+};
+
+exports.qname = function (qname) {
+  exports.name(qname);
+
+  const result = xnv.qname(qname);
+  if (!result.success) {
+    throw new DOMException(DOMException.NAMESPACE_ERR,
+      "\"" + qname + "\" did not match the QName production: " + result.error);
+  }
+};
+
+exports.validateAndExtract = function (namespace, qualifiedName) {
+  if (namespace === "") {
+    namespace = null;
+  }
+
+  exports.qname(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 new DOMException(DOMException.NAMESPACE_ERR,
+      "A namespace was given but a prefix was also extracted from the qualifiedName");
+  }
+
+  if (prefix === "xml" && namespace !== "http://www.w3.org/XML/1998/namespace") {
+    throw new DOMException(DOMException.NAMESPACE_ERR,
+      "A prefix of \"xml\" was given but the namespace was not the XML namespace");
+  }
+
+  if ((qualifiedName === "xmlns" || prefix === "xmlns") && namespace !== "http://www.w3.org/2000/xmlns/") {
+    throw new DOMException(DOMException.NAMESPACE_ERR,
+      "A prefix or qualifiedName of \"xmlns\" was given but the namespace was not the XMLNS namespace");
+  }
+
+  if (namespace === "http://www.w3.org/2000/xmlns/" && qualifiedName !== "xmlns" && prefix !== "xmlns") {
+    throw new DOMException(DOMException.NAMESPACE_ERR,
+      "The XMLNS namespace was given but neither the prefix nor qualifiedName was \"xmlns\"");
+  }
+
+  return { namespace, prefix, localName };
+};

node_modules/jsdom/lib/jsdom/living/html-collection.js

@@ -0,0 +1,95 @@
+"use strict";
+const lengthFromProperties = require("../utils").lengthFromProperties;
+const getAttributeValue = require("./attributes").getAttributeValue;
+
+const privates = Symbol("HTMLCollection internal slots");
+
+class HTMLCollection {
+  constructor(secret, element, query) {
+    if (secret !== privates) {
+      throw new TypeError("Invalid constructor");
+    }
+
+    this[privates] = { element, query, snapshot: undefined, keys: [], length: 0, version: -1 };
+    updateHTMLCollection(this);
+  }
+
+  get length() {
+    updateHTMLCollection(this);
+    return this[privates].length;
+  }
+
+  item(index) {
+    updateHTMLCollection(this);
+    return this[index] || null;
+  }
+
+  namedItem(name) {
+    updateHTMLCollection(this);
+
+    if (Object.prototype.hasOwnProperty.call(this, name)) {
+      return this[name];
+    }
+    return null;
+  }
+}
+
+function updateHTMLCollection(collection) {
+  if (collection[privates].version < collection[privates].element._version) {
+    collection[privates].snapshot = collection[privates].query();
+    resetHTMLCollectionTo(collection, collection[privates].snapshot);
+    collection[privates].version = collection[privates].element._version;
+  }
+}
+
+function resetHTMLCollectionTo(collection, els) {
+  const startingLength = lengthFromProperties(collection);
+  for (let i = 0; i < startingLength; ++i) {
+    delete collection[i];
+  }
+
+  for (let i = 0; i < els.length; ++i) {
+    collection[i] = els[i];
+  }
+  collection[privates].length = els.length;
+
+  const keys = collection[privates].keys;
+  for (let i = 0; i < keys.length; ++i) {
+    delete collection[keys[i]];
+  }
+  keys.length = 0;
+
+  for (let i = 0; i < els.length; ++i) {
+    addIfAttrPresent(els[i], "name");
+  }
+  for (let i = 0; i < els.length; ++i) {
+    addIfAttrPresent(els[i], "id");
+  }
+
+  function addIfAttrPresent(el, attr) {
+    const value = getAttributeValue(el, attr);
+
+    if (value === null || value === "") {
+      return;
+    }
+
+    // Don't overwrite numeric indices with named ones.
+    const valueAsNumber = Number(value);
+    if (!Number.isNaN(valueAsNumber) && valueAsNumber >= 0) {
+      return;
+    }
+
+    collection[value] = el;
+    keys.push(value);
+  }
+}
+
+module.exports = function (core) {
+  core.HTMLCollection = HTMLCollection;
+};
+
+module.exports.create = function (element, query) {
+  return new HTMLCollection(privates, element, query);
+};
+
+module.exports.update = updateHTMLCollection;

node_modules/jsdom/lib/jsdom/living/index.js

@@ -0,0 +1,39 @@
+"use strict";
+const core = module.exports = require("../level1/core");
+
+// These (because of how they were written) directly include level1/core and modify it.
+// ORDER IS IMPORTANT
+require("../level2/core");
+require("../level2/events");
+require("../level2/html");
+require("../level2/style");
+require("../level3/core");
+require("../level3/ls");
+require("../level3/xpath");
+
+require("./document-type")(core);
+require("./character-data")(core);
+require("./processing-instruction")(core);
+require("./comment")(core);
+require("./text")(core);
+require("./dom-implementation")(core);
+require("./document")(core);
+require("./element")(core);
+require("./html-collection")(core);
+require("./node-filter")(core);
+require("./node-iterator")(core);
+require("./node-list")(core);
+require("./node")(core);
+require("./selectors")(core);
+require("./parent-node")(core);
+require("./non-document-type-child-node")(core);
+require("./url")(core);
+require("./blob")(core);
+require("./file")(core);
+require("./filelist")(core);
+require("./form-data")(core);
+require("./xmlhttprequest-event-target")(core);
+require("./xmlhttprequest-upload")(core);
+
+core.Attr = require("./generated/Attr").interface;
+core.DOMTokenList = require("./dom-token-list").DOMTokenList;

node_modules/jsdom/lib/jsdom/living/named-properties-window.js

@@ -0,0 +1,137 @@
+"use strict";
+const hasOwnProp = Object.prototype.hasOwnProperty;
+const namedPropertiesTracker = require("../named-properties-tracker");
+const NODE_TYPE = require("./node-type");
+const createHTMLCollection = require("./html-collection").create;
+const treeOrderSorter = require("../utils").treeOrderSorter;
+
+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 "APPLET":
+    case "AREA":
+    case "EMBED":
+    case "FORM":
+    case "FRAMESET":
+    case "IMG":
+    case "OBJECT":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function namedPropertyResolver(HTMLCollection, window, name, values) {
+  function getResult() {
+    const results = [];
+
+    for (const node of values().keys()) {
+      if (node.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+        continue;
+      }
+
+      if (node.getAttribute("id") === name) {
+        results.push(node);
+      } else if (node.getAttribute("name") === name && isNamedPropertyElement(node)) {
+        results.push(node);
+      }
+    }
+
+    results.sort(treeOrderSorter);
+
+    return results;
+  }
+
+  const document = window._document;
+  const objects = createHTMLCollection(document.documentElement, getResult);
+
+  const length = objects.length;
+  for (let i = 0; i < length; ++i) {
+    const node = objects[i];
+
+    if ("contentWindow" in node && !hasOwnProp.call(node, "contentWindow")) {
+      return node.contentWindow;
+    }
+  }
+
+  if (length === 0) {
+    return undefined;
+  }
+
+  if (length === 1) {
+    return objects[0];
+  }
+
+  return objects;
+}
+
+exports.initializeWindow = function (window, HTMLCollection) {
+  namedPropertiesTracker.create(window, namedPropertyResolver.bind(null, HTMLCollection));
+};
+
+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.getAttribute("name") !== oldValue)) {
+        tracker.untrack(oldValue, element);
+      }
+
+      if (name === "name" && element.getAttribute("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.getAttribute("id"), node);
+
+  if (isNamedPropertyElement(node)) {
+    tracker.track(node.getAttribute("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.getAttribute("id"), node);
+
+  if (isNamedPropertyElement(node)) {
+    tracker.untrack(node.getAttribute("name"), node);
+  }
+};

node_modules/jsdom/lib/jsdom/living/node-filter.js

@@ -0,0 +1,47 @@
+"use strict";
+const addConstants = require("../utils").addConstants;
+
+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
+  });
+};

node_modules/jsdom/lib/jsdom/living/node-iterator.js

@@ -0,0 +1,229 @@
+"use strict";
+
+const domSymbolTree = require("./helpers/internal-constants").domSymbolTree;
+const defineGetter = require("../utils").defineGetter;
+const INTERNAL = Symbol("NodeIterator internal");
+
+module.exports = function (core) {
+  // https://dom.spec.whatwg.org/#interface-nodeiterator
+
+  function NodeIteratorInternal(document, root, whatToShow, filter) {
+    this.active = true;
+    this.document = document;
+    this.root = root;
+    this.referenceNode = root;
+    this.pointerBeforeReferenceNode = true;
+    this.whatToShow = whatToShow;
+    this.filter = filter;
+  }
+
+  NodeIteratorInternal.prototype.throwIfNotActive = function () {
+    // (only thrown for getters/methods that are affected by removing steps)
+    if (!this.active) {
+      throw Error("This NodeIterator is no longer active. " +
+                  "More than " + this.document._activeNodeIteratorsMax +
+                  " iterators are being used concurrently. " +
+                  "You can increase the 'concurrentNodeIterators' option to " +
+                  "make this error go away."
+      );
+      // Alternatively, you can pester Ecma to add support for weak references,
+      // the DOM standard assumes the implementor has control over object life cycles.
+    }
+  };
+
+  NodeIteratorInternal.prototype.traverse = function (next) {
+    let node = this.referenceNode;
+    let beforeNode = this.pointerBeforeReferenceNode;
+
+    do {
+      if (next) {
+        if (!beforeNode) {
+          node = domSymbolTree.following(node, { root: this.root });
+
+          if (!node) {
+            return null;
+          }
+        }
+
+        beforeNode = false;
+      } else { // previous
+        if (beforeNode) {
+          node = domSymbolTree.preceding(node, { root: this.root });
+
+          if (!node) {
+            return null;
+          }
+        }
+
+        beforeNode = true;
+      }
+    }
+    while (this.filterNode(node) !== core.NodeFilter.FILTER_ACCEPT);
+
+    this.pointerBeforeReferenceNode = beforeNode;
+    this.referenceNode = node;
+    return node;
+  };
+
+  NodeIteratorInternal.prototype.filterNode = function (node) {
+    const n = node.nodeType - 1;
+    if (!(this.whatToShow & (1 << n))) {
+      return core.NodeFilter.FILTER_SKIP;
+    }
+
+    let ret = core.NodeFilter.FILTER_ACCEPT;
+    const filter = this.filter;
+    if (typeof filter === "function") {
+      ret = filter(node);
+    } else if (filter && typeof filter.acceptNode === "function") {
+      ret = filter.acceptNode(node);
+    }
+
+    if (ret === true) {
+      return core.NodeFilter.FILTER_ACCEPT;
+    } else if (ret === false) {
+      return core.NodeFilter.FILTER_REJECT;
+    }
+
+    return ret;
+  };
+
+  NodeIteratorInternal.prototype.runRemovingSteps = function (oldNode, oldParent, oldPreviousSibling) {
+    if (oldNode.contains(this.root)) {
+      return;
+    }
+
+    // If oldNode is not an inclusive ancestor of the referenceNode
+    // attribute value, terminate these steps.
+    if (!oldNode.contains(this.referenceNode)) {
+      return;
+    }
+
+    if (this.pointerBeforeReferenceNode) {
+      // Let nextSibling be oldPreviousSibling’s next sibling, if oldPreviousSibling is non-null,
+      // and oldParent’s first child otherwise.
+      const nextSibling = oldPreviousSibling ?
+                          oldPreviousSibling.nextSibling :
+                          oldParent.firstChild;
+
+      // If nextSibling is non-null, set the referenceNode attribute to nextSibling
+      // and terminate these steps.
+      if (nextSibling) {
+        this.referenceNode = nextSibling;
+        return;
+      }
+
+      // Let next be the first node following oldParent (excluding any children of oldParent).
+      const next = domSymbolTree.following(oldParent, { skipChildren: true });
+
+      // If root is an inclusive ancestor of next, set the referenceNode
+      // attribute to next and terminate these steps.
+      if (this.root.contains(next)) {
+        this.referenceNode = next;
+        return;
+      }
+
+      // Otherwise, set the pointerBeforeReferenceNode attribute to false.
+      this.pointerBeforeReferenceNode = false;
+
+      // Note: Steps are not terminated here.
+    }
+
+    // Set the referenceNode attribute to the last inclusive descendant in tree order of oldPreviousSibling,
+    // if oldPreviousSibling is non-null, and to oldParent otherwise.
+    this.referenceNode = oldPreviousSibling ?
+                             domSymbolTree.lastInclusiveDescendant(oldPreviousSibling) :
+                             oldParent;
+  };
+
+  core.Document._removingSteps.push((document, oldNode, oldParent, oldPreviousSibling) => {
+    for (let i = 0; i < document._activeNodeIterators.length; ++i) {
+      const internal = document._activeNodeIterators[i];
+      internal.runRemovingSteps(oldNode, oldParent, oldPreviousSibling);
+    }
+  });
+
+  core.Document.prototype.createNodeIterator = function (root, whatToShow, filter) {
+    if (!root) {
+      throw new TypeError("Not enough arguments to Document.createNodeIterator.");
+    }
+
+    if (filter === undefined) {
+      filter = null;
+    }
+
+    if (filter !== null &&
+        typeof filter !== "function" &&
+        typeof filter.acceptNode !== "function") {
+      throw new TypeError("Argument 3 of Document.createNodeIterator should be a function or implement NodeFilter.");
+    }
+
+    const document = root._ownerDocument;
+
+    whatToShow = whatToShow === undefined ?
+      core.NodeFilter.SHOW_ALL :
+      (whatToShow & core.NodeFilter.SHOW_ALL) >>> 0; // >>> makes sure the result is unsigned
+
+    filter = filter || null;
+
+    const it = Object.create(core.NodeIterator.prototype);
+    const internal = new NodeIteratorInternal(document, root, whatToShow, filter);
+    it[INTERNAL] = internal;
+
+    document._activeNodeIterators.push(internal);
+    while (document._activeNodeIterators.length > document._activeNodeIteratorsMax) {
+      const internalOther = document._activeNodeIterators.shift();
+      internalOther.active = false;
+    }
+
+    return it;
+  };
+
+  core.NodeIterator = function NodeIterator() {
+    throw new TypeError("Illegal constructor");
+  };
+
+  defineGetter(core.NodeIterator.prototype, "root", function () {
+    return this[INTERNAL].root;
+  });
+
+  defineGetter(core.NodeIterator.prototype, "referenceNode", function () {
+    const internal = this[INTERNAL];
+    internal.throwIfNotActive();
+    return internal.referenceNode;
+  });
+
+  defineGetter(core.NodeIterator.prototype, "pointerBeforeReferenceNode", function () {
+    const internal = this[INTERNAL];
+    internal.throwIfNotActive();
+    return internal.pointerBeforeReferenceNode;
+  });
+
+  defineGetter(core.NodeIterator.prototype, "whatToShow", function () {
+    return this[INTERNAL].whatToShow;
+  });
+
+  defineGetter(core.NodeIterator.prototype, "filter", function () {
+    return this[INTERNAL].filter;
+  });
+
+  core.NodeIterator.prototype.previousNode = function () {
+    const internal = this[INTERNAL];
+    internal.throwIfNotActive();
+    return internal.traverse(false);
+  };
+
+  core.NodeIterator.prototype.nextNode = function () {
+    const internal = this[INTERNAL];
+    internal.throwIfNotActive();
+    return internal.traverse(true);
+  };
+
+  core.NodeIterator.prototype.detach = function () {
+    // noop
+  };
+
+  core.NodeIterator.prototype.toString = function () {
+    return "[object NodeIterator]";
+  };
+};

node_modules/jsdom/lib/jsdom/living/node-list.js

@@ -0,0 +1,83 @@
+"use strict";
+const lengthFromProperties = require("../utils").lengthFromProperties;
+
+const privates = Symbol("NodeList internal slots");
+
+class NodeList {
+  constructor(secret, config) {
+    if (secret !== privates) {
+      throw new TypeError("Invalid constructor");
+    }
+
+    if (config.nodes) {
+      this[privates] = {
+        isLive: false,
+        length: config.nodes.length
+      };
+
+      for (let i = 0; i < config.nodes.length; ++i) {
+        this[i] = config.nodes[i];
+      }
+    } else {
+      this[privates] = {
+        isLive: true,
+        element: config.element,
+        query: config.query,
+        snapshot: undefined,
+        length: 0,
+        version: -1
+      };
+      updateNodeList(this);
+    }
+  }
+
+  get length() {
+    updateNodeList(this);
+    return this[privates].length;
+  }
+
+  item(index) {
+    updateNodeList(this);
+    return this[index] || null;
+  }
+}
+
+NodeList.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
+
+function updateNodeList(nodeList) {
+  if (nodeList[privates].isLive) {
+    if (nodeList[privates].version < nodeList[privates].element._version) {
+      nodeList[privates].snapshot = nodeList[privates].query();
+      resetNodeListTo(nodeList, nodeList[privates].snapshot);
+      nodeList[privates].version = nodeList[privates].element._version;
+    }
+  } else {
+    nodeList[privates].length = lengthFromProperties(nodeList);
+  }
+}
+
+function resetNodeListTo(nodeList, nodes) {
+  const startingLength = lengthFromProperties(nodeList);
+  for (let i = 0; i < startingLength; ++i) {
+    delete nodeList[i];
+  }
+
+  for (let i = 0; i < nodes.length; ++i) {
+    nodeList[i] = nodes[i];
+  }
+  nodeList[privates].length = nodes.length;
+}
+
+module.exports = function (core) {
+  core.NodeList = NodeList;
+};
+
+module.exports.createLive = function (element, query) {
+  return new NodeList(privates, { element, query });
+};
+
+module.exports.createStatic = function (nodes) {
+  return new NodeList(privates, { nodes });
+};
+
+module.exports.update = updateNodeList;

node_modules/jsdom/lib/jsdom/living/node-type.js

@@ -0,0 +1,16 @@
+"use strict";
+
+module.exports = Object.freeze({
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2, // historical
+  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
+});

node_modules/jsdom/lib/jsdom/living/node.js

@@ -0,0 +1,250 @@
+"use strict";
+const defineGetter = require("../utils").defineGetter;
+const simultaneousIterators = require("../utils").simultaneousIterators;
+const attributes = require("./attributes");
+const cloneDoctype = require("./document-type").clone;
+const cloningSteps = require("./helpers/internal-constants").cloningSteps;
+const domSymbolTree = require("./helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("./node-type");
+const documentBaseURL = require("./helpers/document-base-url").documentBaseURL;
+const orderedSetParser = require("./helpers/ordered-set-parser");
+const createHTMLCollection = require("./html-collection").create;
+const domTokenListContains = require("./dom-token-list").contains;
+const getDoctypePrivates = require("./document-type").getPrivates;
+
+module.exports = function (core) {
+  const DOCUMENT_POSITION_DISCONNECTED = core.Node.DOCUMENT_POSITION_DISCONNECTED;
+  const DOCUMENT_POSITION_FOLLOWING = core.Node.DOCUMENT_POSITION_FOLLOWING;
+  const DOCUMENT_POSITION_CONTAINED_BY = core.Node.DOCUMENT_POSITION_CONTAINED_BY;
+  const DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = core.Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
+
+  /**
+   * Return true if node is of a type obsoleted by the WHATWG living standard
+   * @param  {Node}  node
+   * @return {Boolean}
+   */
+  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;
+  }
+
+  core.Node.prototype.cloneNode = function (deep) {
+    deep = Boolean(deep);
+
+    return module.exports.clone(core, this, undefined, deep);
+  };
+
+  /**
+   * Returns a bitmask Number composed of DOCUMENT_POSITION constants based upon the rules defined in
+   * http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
+   * @param  {Node} other
+   * @return {Number}
+   */
+  core.Node.prototype.compareDocumentPosition = function (other) {
+    // Let reference be the context object.
+    const reference = this;
+
+    if (!(other instanceof core.Node)) {
+      throw new Error("Comparing position against non-Node values is not allowed");
+    }
+
+    if (isObsoleteNodeType(reference) || isObsoleteNodeType(other)) {
+      throw new Error("Obsolete node type");
+    }
+
+    const result = domSymbolTree.compareTreePosition(reference, other);
+
+    // “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 === DOCUMENT_POSITION_DISCONNECTED) {
+      // symbol-tree does not add these bits required by the spec:
+      return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
+    }
+
+    return result;
+  };
+
+  /**
+   * The contains(other) method returns true if other is an inclusive descendant of the context object,
+   * and false otherwise (including when other is null).
+   * @param  {[Node]} other [the node to test]
+   * @return {[boolean]}      [whether other is an inclusive descendant of this]
+   */
+  core.Node.prototype.contains = function (other) {
+    return Boolean(other instanceof core.Node &&
+                   (this === other || this.compareDocumentPosition(other) & DOCUMENT_POSITION_CONTAINED_BY)
+                  );
+  };
+
+  // http://dom.spec.whatwg.org/#dom-node-parentelement
+  defineGetter(core.Node.prototype, "parentElement", function () {
+    const parentNode = domSymbolTree.parent(this);
+    return parentNode !== null && parentNode.nodeType === NODE_TYPE.ELEMENT_NODE ? parentNode : null;
+  });
+
+  // https://dom.spec.whatwg.org/#dom-node-baseuri
+  defineGetter(core.Node.prototype, "baseURI", function () {
+    return documentBaseURL(this._ownerDocument);
+  });
+
+  function nodeEquals(a, b) {
+    if (a.nodeType !== b.nodeType) {
+      return false;
+    }
+
+    switch (a.nodeType) {
+      case NODE_TYPE.DOCUMENT_TYPE_NODE:
+        const privatesA = getDoctypePrivates(a);
+        const privatesB = getDoctypePrivates(b);
+        if (privatesA.name !== privatesB.name || privatesA.publicId !== privatesB.publicId ||
+            privatesA.systemId !== privatesB.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.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 && !attributes.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;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-node-isequalnode
+  core.Node.prototype.isEqualNode = function (node) {
+    if (node === undefined) {
+      // this is what Node? means in the IDL
+      node = null;
+    }
+
+    if (node === null) {
+      return false;
+    }
+
+    // Fast-path, not in the spec
+    if (this === node) {
+      return true;
+    }
+
+    return nodeEquals(this, node);
+  };
+};
+
+module.exports.clone = function (core, node, document, cloneChildren) {
+  if (document === undefined) {
+    document = node._ownerDocument;
+  }
+
+  let copy;
+  switch (node.nodeType) {
+    case NODE_TYPE.DOCUMENT_NODE:
+      // TODO: just use Document when we eliminate the difference between Document and HTMLDocument.
+      copy = new node.constructor({
+        contentType: node._contentType,
+        url: node._URL,
+        parsingMode: node._parsingMode
+      });
+      document = copy;
+      break;
+
+    case NODE_TYPE.DOCUMENT_TYPE_NODE:
+      copy = cloneDoctype(core, node);
+      break;
+
+    case NODE_TYPE.ELEMENT_NODE:
+      copy = document._createElementWithCorrectElementInterface(node._localName, node._namespaceURI);
+      copy._namespaceURI = node._namespaceURI;
+      copy._prefix = node._prefix;
+      copy._localName = node._localName;
+      attributes.copyAttributeList(node, copy);
+      break;
+
+    case NODE_TYPE.TEXT_NODE:
+      copy = new core.Text(document, node._data);
+      break;
+
+    case NODE_TYPE.COMMENT_NODE:
+      copy = new core.Comment(document, node._data);
+      break;
+
+    case NODE_TYPE.PROCESSING_INSTRUCTION_NODE:
+      copy = new core.ProcessingInstruction(document, node._target, node._data);
+      break;
+
+    case NODE_TYPE.DOCUMENT_FRAGMENT_NODE:
+      copy = new core.DocumentFragment(document);
+      break;
+  }
+
+  if (node[cloningSteps]) {
+    node[cloningSteps](copy, node, document, cloneChildren);
+  }
+
+  if (cloneChildren) {
+    for (const child of domSymbolTree.childrenIterator(node)) {
+      const childCopy = module.exports.clone(core, child, document, true);
+      copy.appendChild(childCopy);
+    }
+  }
+
+  return copy;
+};
+
+module.exports.listOfElementsWithClassNames = function (classNames, root) {
+  // https://dom.spec.whatwg.org/#concept-getElementsByClassName
+
+  const classes = orderedSetParser(classNames);
+
+  if (classes.size === 0) {
+    return createHTMLCollection(root, () => false);
+  }
+
+  return createHTMLCollection(root, () => {
+    const isQuirksMode = root._ownerDocument.compatMode === "BackCompat";
+
+    return domSymbolTree.treeToArray(root, { filter(node) {
+      if (node.nodeType !== NODE_TYPE.ELEMENT_NODE || node === root) {
+        return false;
+      }
+
+      for (const className of classes) {
+        if (!domTokenListContains(node.classList, className, { caseInsensitive: isQuirksMode })) {
+          return false;
+        }
+      }
+
+      return true;
+    } });
+  });
+};

node_modules/jsdom/lib/jsdom/living/non-document-type-child-node.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const defineGetter = require("../utils").defineGetter;
+const domSymbolTree = require("./helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("./node-type");
+
+module.exports = function (core) {
+  // https://dom.spec.whatwg.org/#nondocumenttypechildnode
+
+  for (const Constructor of [core.Element, core.CharacterData]) {
+    defineGetter(Constructor.prototype, "nextElementSibling", function () {
+      for (const sibling of domSymbolTree.nextSiblingsIterator(this)) {
+        if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+          return sibling;
+        }
+      }
+      return null;
+    });
+
+    defineGetter(Constructor.prototype, "previousElementSibling", function () {
+      for (const sibling of domSymbolTree.previousSiblingsIterator(this)) {
+        if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+          return sibling;
+        }
+      }
+      return null;
+    });
+  }
+};

node_modules/jsdom/lib/jsdom/living/parent-node.js

@@ -0,0 +1,50 @@
+"use strict";
+const defineGetter = require("../utils").defineGetter;
+const domSymbolTree = require("./helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("./node-type");
+const createHTMLCollection = require("./html-collection").create;
+const updateHTMLCollection = require("./html-collection").update;
+
+module.exports = function (core) {
+  // https://dom.spec.whatwg.org/#interface-parentnode
+  // Note that ParentNode is a "NoInterfaceObject"
+
+  for (const Constructor of [core.Document, core.DocumentFragment, core.Element]) {
+    defineGetter(Constructor.prototype, "children", function () {
+      if (!this._childrenList) {
+        this._childrenList = createHTMLCollection(this, () => {
+          return domSymbolTree.childrenToArray(this, { filter(node) {
+            return node.nodeType === NODE_TYPE.ELEMENT_NODE;
+          } });
+        });
+      } else {
+        updateHTMLCollection(this._childrenList);
+      }
+      return this._childrenList;
+    });
+
+    defineGetter(Constructor.prototype, "firstElementChild", function () {
+      for (const child of domSymbolTree.childrenIterator(this)) {
+        if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+          return child;
+        }
+      }
+
+      return null;
+    });
+
+    defineGetter(Constructor.prototype, "lastElementChild", function () {
+      for (const child of domSymbolTree.childrenIterator(this, { reverse: true })) {
+        if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+          return child;
+        }
+      }
+
+      return null;
+    });
+
+    defineGetter(Constructor.prototype, "childElementCount", function () {
+      return this.children.length;
+    });
+  }
+};

node_modules/jsdom/lib/jsdom/living/post-message.js

@@ -0,0 +1,36 @@
+"use strict";
+const isValidTargetOrigin = require("../utils").isValidTargetOrigin;
+const DOMException = require("../web-idl/DOMException");
+
+module.exports = function (message, targetOrigin) {
+  if (arguments.length < 2) {
+    throw new TypeError("'postMessage' requires 2 arguments: 'message' and 'targetOrigin'");
+  }
+
+  targetOrigin = String(targetOrigin);
+
+  if (!isValidTargetOrigin(targetOrigin)) {
+    throw new DOMException(DOMException.SYNTAX_ERR, "Failed to execute 'postMessage' on 'Window': " +
+      "Invalid target origin '" + targetOrigin + "' in a call to 'postMessage'.");
+  }
+
+  // TODO: targetOrigin === '/' - requires reference to source window
+  // See https://github.com/tmpvar/jsdom/pull/1140#issuecomment-111587499
+  if (targetOrigin !== "*" && targetOrigin !== this.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
+  const event = new this.MessageEvent("message", {
+    data: message
+  });
+
+  event.initEvent("message", false, false);
+
+  setTimeout(() => {
+    this.dispatchEvent(event);
+  }, 0);
+};

node_modules/jsdom/lib/jsdom/living/processing-instruction.js

@@ -0,0 +1,18 @@
+"use strict";
+const inheritFrom = require("../utils").inheritFrom;
+const NODE_TYPE = require("../living/node-type");
+
+module.exports = function (core) {
+  core.ProcessingInstruction = function ProcessingInstruction(ownerDocument, target, data) {
+    core.CharacterData.call(this, ownerDocument, data);
+
+    this._target = target;
+  };
+
+  inheritFrom(core.CharacterData, core.ProcessingInstruction, {
+    nodeType: NODE_TYPE.PROCESSING_INSTRUCTION_NODE, // TODO should be on prototype, not here
+    get target() {
+      return this._target;
+    }
+  });
+};

node_modules/jsdom/lib/jsdom/living/selectors.js

@@ -0,0 +1,71 @@
+"use strict";
+const nwmatcher = require("nwmatcher/src/nwmatcher-noqsa");
+const memoizeQuery = require("../utils").memoizeQuery;
+const domSymbolTree = require("./helpers/internal-constants").domSymbolTree;
+const createStaticNodeList = require("../living/node-list").createStatic;
+const DOMException = require("../web-idl/DOMException");
+
+module.exports = function (core) {
+  for (const Class of [core.Document, core.DocumentFragment, core.Element]) {
+    Class.prototype.querySelector = memoizeQuery(function (selectors) {
+      selectors = String(selectors);
+      const matcher = addNwmatcher(this);
+
+      try {
+        return matcher.first(selectors, this);
+      } catch (e) {
+        throw new DOMException(DOMException.SYNTAX_ERR, e.message);
+      }
+    });
+
+    Class.prototype.querySelectorAll = memoizeQuery(function (selectors) {
+      selectors = String(selectors);
+      const matcher = addNwmatcher(this);
+
+      let list;
+      try {
+        list = matcher.select(selectors, this);
+      } catch (e) {
+        throw new DOMException(DOMException.SYNTAX_ERR, e.message);
+      }
+
+      return createStaticNodeList(list);
+    });
+  }
+
+  core.Element.prototype.matches = memoizeQuery(function (selectors) {
+    selectors = String(selectors);
+    const matcher = addNwmatcher(this);
+
+    try {
+      return matcher.match(this, selectors);
+    } catch (e) {
+      throw new DOMException(DOMException.SYNTAX_ERR, e.message);
+    }
+  });
+};
+
+// Internal method so you don't have to go through the public API
+module.exports.querySelector = function (parentNode, selectors) {
+  if (!domSymbolTree.hasChildren(parentNode) ||
+      (parentNode === parentNode._ownerDocument && !parentNode._documentElement)) {
+    // This allows us to avoid the explosion that occurs if you try to add nwmatcher to a document that is not yet
+    // initialized.
+    return null;
+  }
+
+  return addNwmatcher(parentNode).first(selectors, parentNode);
+};
+
+// nwmatcher 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.
+function addNwmatcher(parentNode) {
+  const document = parentNode._ownerDocument;
+
+  if (!document._nwmatcher) {
+    document._nwmatcher = nwmatcher({ document });
+    document._nwmatcher.configure({ UNIQUE_ID: false });
+  }
+
+  return document._nwmatcher;
+}