Fix.

node_modules/data-urls/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright © 2017–2018 Domenic Denicola <d@domenic.me>
+
+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/data-urls/README.md

@@ -0,0 +1,64 @@
+# Parse `data:` URLs
+
+This package helps you parse `data:` URLs [according to the WHATWG Fetch Standard](https://fetch.spec.whatwg.org/#data-urls):
+
+```js
+const parseDataURL = require("data-url");
+
+const textExample = parseDataURL("data:,Hello%2C%20World!");
+console.log(textExample.mimeType.toString()); // "text/plain;charset=US-ASCII"
+console.log(textExample.body.toString());     // "Hello, World!"
+
+const htmlExample = dataURL("data:text/html,%3Ch1%3EHello%2C%20World!%3C%2Fh1%3E");
+console.log(htmlExample.mimeType.toString()); // "text/html"
+console.log(htmlExample.body.toString());     // <h1>Hello, World!</h1>
+
+const pngExample = parseDataURL("data:image/png;base64,iVBORw0KGgoAAA" +
+                                "ANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" +
+                                "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU" +
+                                "5ErkJggg==");
+console.log(pngExample.mimeType.toString()); // "image/png"
+console.log(pngExample.body);                // <Buffer 89 50 4e 47 0d ... >
+```
+
+## API
+
+This package's main module's default export is a function that accepts a string and returns a `{ mimeType, body }` object, or `null` if the result cannot be parsed as a `data:` URL.
+
+- The `mimeType` property is an instance of [whatwg-mimetype](https://www.npmjs.com/package/whatwg-mimetype)'s `MIMEType` class.
+- The `body` property is a Node.js [`Buffer`](https://nodejs.org/docs/latest/api/buffer.html) instance.
+
+As shown in the examples above, both of these have useful `toString()` methods for manipulating them as string values. However…
+
+### A word of caution on string decoding
+
+Because Node.js's `Buffer.prototype.toString()` assumes a UTF-8 encoding, simply doing `dataURL.body.toString()` may not work correctly if the `data:` URL's contents were not originally written in UTF-8. This includes if the encoding is "US-ASCII", [aka windows-1252](https://encoding.spec.whatwg.org/#names-and-labels), which is notable for being the default in many cases.
+
+A more complete decoding example would use the [whatwg-encoding](https://www.npmjs.com/package/whatwg-encoding) package as follows:
+
+```js
+const parseDataURL = require("data-url");
+const { labelToName, decode } = require("whatwg-encoding");
+
+const dataURL = parseDataURL(arbitraryString);
+const encodingName = labelToName(dataURL.mimeType.parameters.get("charset"));
+const bodyDecoded = decode(dataURL.body, encodingName);
+```
+
+For example, given an `arbitraryString` of `data:,Hello!`, this will produce a `bodyDecoded` of `"Hello!"`, as expected. But given an `arbitraryString` of `"data:,Héllo!"`, this will correctly produce a `bodyDecoded` of `"Héllo!"`, whereas just doing `dataURL.body.toString()` will give back `"Héllo!"`.
+
+In summary, only use `dataURL.body.toString()` when you are very certain your data is inside the ASCII range (i.e. code points within the range U+0000 to U+007F).
+
+### Advanced functionality: parsing from a URL record
+
+If you are using the [whatwg-url](https://github.com/jsdom/whatwg-url) package, you may already have a "URL record" object on hand, as produced by that package's `parseURL` export. In that case, you can use this package's `fromURLRecord` export to save a bit of work:
+
+```js
+const { parseURL } = require("whatwg-url");
+const dataURLFromURLRecord = require("data-url").fromURLRecord;
+
+const urlRecord = parseURL("data:,Hello%2C%20World!");
+const dataURL = dataURLFromURLRecord(urlRecord);
+```
+
+In practice, we expect this functionality only to be used by consumers like [jsdom](https://www.npmjs.com/package/jsdom), which are using these packages at a very low level.

node_modules/data-urls/lib/parser.js

@@ -0,0 +1,74 @@
+"use strict";
+const MIMEType = require("whatwg-mimetype");
+const { parseURL, serializeURL } = require("whatwg-url");
+const {
+  stripLeadingAndTrailingASCIIWhitespace,
+  stringPercentDecode,
+  isomorphicDecode,
+  forgivingBase64Decode
+} = require("./utils.js");
+
+module.exports = stringInput => {
+  const urlRecord = parseURL(stringInput);
+
+  if (urlRecord === null) {
+    return null;
+  }
+
+  return module.exports.fromURLRecord(urlRecord);
+};
+
+module.exports.fromURLRecord = urlRecord => {
+  if (urlRecord.scheme !== "data") {
+    return null;
+  }
+
+  const input = serializeURL(urlRecord, true).substring("data:".length);
+
+  let position = 0;
+
+  let mimeType = "";
+  while (position < input.length && input[position] !== ",") {
+    mimeType += input[position];
+    ++position;
+  }
+  mimeType = stripLeadingAndTrailingASCIIWhitespace(mimeType);
+
+  if (position === input.length) {
+    return null;
+  }
+
+  ++position;
+
+  const encodedBody = input.substring(position);
+
+  let body = stringPercentDecode(encodedBody);
+
+  // Can't use /i regexp flag because it isn't restricted to ASCII.
+  const mimeTypeBase64MatchResult = /(.*); *[Bb][Aa][Ss][Ee]64$/.exec(mimeType);
+  if (mimeTypeBase64MatchResult) {
+    const stringBody = isomorphicDecode(body);
+    body = forgivingBase64Decode(stringBody);
+
+    if (body === null) {
+      return null;
+    }
+    mimeType = mimeTypeBase64MatchResult[1];
+  }
+
+  if (mimeType.startsWith(";")) {
+    mimeType = "text/plain" + mimeType;
+  }
+
+  let mimeTypeRecord;
+  try {
+    mimeTypeRecord = new MIMEType(mimeType);
+  } catch (e) {
+    mimeTypeRecord = new MIMEType("text/plain;charset=US-ASCII");
+  }
+
+  return {
+    mimeType: mimeTypeRecord,
+    body
+  };
+};

node_modules/data-urls/lib/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+const { percentDecode } = require("whatwg-url");
+const { atob } = require("abab");
+
+exports.stripLeadingAndTrailingASCIIWhitespace = string => {
+  return string.replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
+};
+
+exports.stringPercentDecode = input => {
+  return percentDecode(Buffer.from(input, "utf-8"));
+};
+
+exports.isomorphicDecode = input => {
+  return input.toString("binary");
+};
+
+exports.forgivingBase64Decode = data => {
+  const asString = atob(data);
+  if (asString === null) {
+    return null;
+  }
+  return Buffer.from(asString, "binary");
+};

node_modules/data-urls/node_modules/whatwg-url/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015–2016 Sebastian Mayr
+
+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/data-urls/node_modules/whatwg-url/README.md

@@ -0,0 +1,91 @@
+# whatwg-url
+
+whatwg-url is a full implementation of the WHATWG [URL Standard](https://url.spec.whatwg.org/). It can be used standalone, but it also exposes a lot of the internal algorithms that are useful for integrating a URL parser into a project like [jsdom](https://github.com/tmpvar/jsdom).
+
+## Specification conformance
+
+whatwg-url is currently up to date with the URL spec up to commit [6ef17eb](https://github.com/whatwg/url/commit/6ef17ebe1220a7e7c0cfff0785017502ee18808b).
+
+For `file:` URLs, whose [origin is left unspecified](https://url.spec.whatwg.org/#concept-url-origin), whatwg-url chooses to use a new opaque origin (which serializes to `"null"`).
+
+## API
+
+### The `URL` and `URLSearchParams` classes
+
+The main API is provided by the [`URL`](https://url.spec.whatwg.org/#url-class) and [`URLSearchParams`](https://url.spec.whatwg.org/#interface-urlsearchparams) exports, which follows the spec's behavior in all ways (including e.g. `USVString` conversion). Most consumers of this library will want to use these.
+
+### Low-level URL Standard API
+
+The following methods are exported for use by places like jsdom that need to implement things like [`HTMLHyperlinkElementUtils`](https://html.spec.whatwg.org/#htmlhyperlinkelementutils). They mostly operate on or return an "internal URL" or ["URL record"](https://url.spec.whatwg.org/#concept-url) type.
+
+- [URL parser](https://url.spec.whatwg.org/#concept-url-parser): `parseURL(input, { baseURL, encodingOverride })`
+- [Basic URL parser](https://url.spec.whatwg.org/#concept-basic-url-parser): `basicURLParse(input, { baseURL, encodingOverride, url, stateOverride })`
+- [URL serializer](https://url.spec.whatwg.org/#concept-url-serializer): `serializeURL(urlRecord, excludeFragment)`
+- [Host serializer](https://url.spec.whatwg.org/#concept-host-serializer): `serializeHost(hostFromURLRecord)`
+- [Serialize an integer](https://url.spec.whatwg.org/#serialize-an-integer): `serializeInteger(number)`
+- [Origin](https://url.spec.whatwg.org/#concept-url-origin) [serializer](https://html.spec.whatwg.org/multipage/origin.html#ascii-serialisation-of-an-origin): `serializeURLOrigin(urlRecord)`
+- [Set the username](https://url.spec.whatwg.org/#set-the-username): `setTheUsername(urlRecord, usernameString)`
+- [Set the password](https://url.spec.whatwg.org/#set-the-password): `setThePassword(urlRecord, passwordString)`
+- [Cannot have a username/password/port](https://url.spec.whatwg.org/#cannot-have-a-username-password-port): `cannotHaveAUsernamePasswordPort(urlRecord)`
+- [Percent decode](https://url.spec.whatwg.org/#percent-decode): `percentDecode(buffer)`
+
+The `stateOverride` parameter is one of the following strings:
+
+- [`"scheme start"`](https://url.spec.whatwg.org/#scheme-start-state)
+- [`"scheme"`](https://url.spec.whatwg.org/#scheme-state)
+- [`"no scheme"`](https://url.spec.whatwg.org/#no-scheme-state)
+- [`"special relative or authority"`](https://url.spec.whatwg.org/#special-relative-or-authority-state)
+- [`"path or authority"`](https://url.spec.whatwg.org/#path-or-authority-state)
+- [`"relative"`](https://url.spec.whatwg.org/#relative-state)
+- [`"relative slash"`](https://url.spec.whatwg.org/#relative-slash-state)
+- [`"special authority slashes"`](https://url.spec.whatwg.org/#special-authority-slashes-state)
+- [`"special authority ignore slashes"`](https://url.spec.whatwg.org/#special-authority-ignore-slashes-state)
+- [`"authority"`](https://url.spec.whatwg.org/#authority-state)
+- [`"host"`](https://url.spec.whatwg.org/#host-state)
+- [`"hostname"`](https://url.spec.whatwg.org/#hostname-state)
+- [`"port"`](https://url.spec.whatwg.org/#port-state)
+- [`"file"`](https://url.spec.whatwg.org/#file-state)
+- [`"file slash"`](https://url.spec.whatwg.org/#file-slash-state)
+- [`"file host"`](https://url.spec.whatwg.org/#file-host-state)
+- [`"path start"`](https://url.spec.whatwg.org/#path-start-state)
+- [`"path"`](https://url.spec.whatwg.org/#path-state)
+- [`"cannot-be-a-base-URL path"`](https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state)
+- [`"query"`](https://url.spec.whatwg.org/#query-state)
+- [`"fragment"`](https://url.spec.whatwg.org/#fragment-state)
+
+The URL record type has the following API:
+
+- [`scheme`](https://url.spec.whatwg.org/#concept-url-scheme)
+- [`username`](https://url.spec.whatwg.org/#concept-url-username)
+- [`password`](https://url.spec.whatwg.org/#concept-url-password)
+- [`host`](https://url.spec.whatwg.org/#concept-url-host)
+- [`port`](https://url.spec.whatwg.org/#concept-url-port)
+- [`path`](https://url.spec.whatwg.org/#concept-url-path) (as an array)
+- [`query`](https://url.spec.whatwg.org/#concept-url-query)
+- [`fragment`](https://url.spec.whatwg.org/#concept-url-fragment)
+- [`cannotBeABaseURL`](https://url.spec.whatwg.org/#url-cannot-be-a-base-url-flag) (as a boolean)
+
+These properties should be treated with care, as in general changing them will cause the URL record to be in an inconsistent state until the appropriate invocation of `basicURLParse` is used to fix it up. You can see examples of this in the URL Standard, where there are many step sequences like "4. Set context object’s url’s fragment to the empty string. 5. Basic URL parse _input_ with context object’s url as _url_ and fragment state as _state override_." In between those two steps, a URL record is in an unusable state.
+
+The return value of "failure" in the spec is represented by `null`. That is, functions like `parseURL` and `basicURLParse` can return _either_ a URL record _or_ `null`.
+
+## Development instructions
+
+First, install [Node.js](https://nodejs.org/). Then, fetch the dependencies of whatwg-url, by running from this directory:
+
+    npm install
+
+To run tests:
+
+    npm test
+
+To generate a coverage report:
+
+    npm run coverage
+
+To build and run the live viewer:
+
+    npm run build
+    npm run build-live-viewer
+
+Serve the contents of the `live-viewer` directory using any web server.

node_modules/data-urls/node_modules/whatwg-url/lib/URL-impl.js

@@ -0,0 +1,217 @@
+"use strict";
+const usm = require("./url-state-machine");
+const urlencoded = require("./urlencoded");
+const URLSearchParams = require("./URLSearchParams");
+
+exports.implementation = class URLImpl {
+  constructor(constructorArgs) {
+    const url = constructorArgs[0];
+    const base = constructorArgs[1];
+
+    let parsedBase = null;
+    if (base !== undefined) {
+      parsedBase = usm.basicURLParse(base);
+      if (parsedBase === null) {
+        throw new TypeError(`Invalid base URL: ${base}`);
+      }
+    }
+
+    const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
+    if (parsedURL === null) {
+      throw new TypeError(`Invalid URL: ${url}`);
+    }
+
+    const query = parsedURL.query !== null ? parsedURL.query : "";
+
+    this._url = parsedURL;
+
+    // We cannot invoke the "new URLSearchParams object" algorithm without going through the constructor, which strips
+    // question mark by default. Therefore the doNotStripQMark hack is used.
+    this._query = URLSearchParams.createImpl([query], { doNotStripQMark: true });
+    this._query._url = this;
+  }
+
+  get href() {
+    return usm.serializeURL(this._url);
+  }
+
+  set href(v) {
+    const parsedURL = usm.basicURLParse(v);
+    if (parsedURL === null) {
+      throw new TypeError(`Invalid URL: ${v}`);
+    }
+
+    this._url = parsedURL;
+
+    this._query._list.splice(0);
+    const { query } = parsedURL;
+    if (query !== null) {
+      this._query._list = urlencoded.parseUrlencoded(query);
+    }
+  }
+
+  get origin() {
+    return usm.serializeURLOrigin(this._url);
+  }
+
+  get protocol() {
+    return this._url.scheme + ":";
+  }
+
+  set protocol(v) {
+    usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" });
+  }
+
+  get username() {
+    return this._url.username;
+  }
+
+  set username(v) {
+    if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
+      return;
+    }
+
+    usm.setTheUsername(this._url, v);
+  }
+
+  get password() {
+    return this._url.password;
+  }
+
+  set password(v) {
+    if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
+      return;
+    }
+
+    usm.setThePassword(this._url, v);
+  }
+
+  get host() {
+    const url = this._url;
+
+    if (url.host === null) {
+      return "";
+    }
+
+    if (url.port === null) {
+      return usm.serializeHost(url.host);
+    }
+
+    return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port);
+  }
+
+  set host(v) {
+    if (this._url.cannotBeABaseURL) {
+      return;
+    }
+
+    usm.basicURLParse(v, { url: this._url, stateOverride: "host" });
+  }
+
+  get hostname() {
+    if (this._url.host === null) {
+      return "";
+    }
+
+    return usm.serializeHost(this._url.host);
+  }
+
+  set hostname(v) {
+    if (this._url.cannotBeABaseURL) {
+      return;
+    }
+
+    usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" });
+  }
+
+  get port() {
+    if (this._url.port === null) {
+      return "";
+    }
+
+    return usm.serializeInteger(this._url.port);
+  }
+
+  set port(v) {
+    if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
+      return;
+    }
+
+    if (v === "") {
+      this._url.port = null;
+    } else {
+      usm.basicURLParse(v, { url: this._url, stateOverride: "port" });
+    }
+  }
+
+  get pathname() {
+    if (this._url.cannotBeABaseURL) {
+      return this._url.path[0];
+    }
+
+    if (this._url.path.length === 0) {
+      return "";
+    }
+
+    return "/" + this._url.path.join("/");
+  }
+
+  set pathname(v) {
+    if (this._url.cannotBeABaseURL) {
+      return;
+    }
+
+    this._url.path = [];
+    usm.basicURLParse(v, { url: this._url, stateOverride: "path start" });
+  }
+
+  get search() {
+    if (this._url.query === null || this._url.query === "") {
+      return "";
+    }
+
+    return "?" + this._url.query;
+  }
+
+  set search(v) {
+    const url = this._url;
+
+    if (v === "") {
+      url.query = null;
+      this._query._list = [];
+      return;
+    }
+
+    const input = v[0] === "?" ? v.substring(1) : v;
+    url.query = "";
+    usm.basicURLParse(input, { url, stateOverride: "query" });
+    this._query._list = urlencoded.parseUrlencoded(input);
+  }
+
+  get searchParams() {
+    return this._query;
+  }
+
+  get hash() {
+    if (this._url.fragment === null || this._url.fragment === "") {
+      return "";
+    }
+
+    return "#" + this._url.fragment;
+  }
+
+  set hash(v) {
+    if (v === "") {
+      this._url.fragment = null;
+      return;
+    }
+
+    const input = v[0] === "#" ? v.substring(1) : v;
+    this._url.fragment = "";
+    usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" });
+  }
+
+  toJSON() {
+    return this.href;
+  }
+};

node_modules/data-urls/node_modules/whatwg-url/lib/URL.js

@@ -0,0 +1,335 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+
+class URL {
+  constructor(url) {
+    if (arguments.length < 1) {
+      throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URL': parameter 1" });
+      args.push(curArg);
+    }
+    {
+      let curArg = arguments[1];
+      if (curArg !== undefined) {
+        curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URL': parameter 2" });
+      }
+      args.push(curArg);
+    }
+    return iface.setup(Object.create(new.target.prototype), args);
+  }
+
+  toJSON() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl].toJSON();
+  }
+
+  get href() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["href"];
+  }
+
+  set href(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'href' property on 'URL': The provided value" });
+
+    this[impl]["href"] = V;
+  }
+
+  toString() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return this[impl]["href"];
+  }
+
+  get origin() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["origin"];
+  }
+
+  get protocol() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["protocol"];
+  }
+
+  set protocol(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'protocol' property on 'URL': The provided value" });
+
+    this[impl]["protocol"] = V;
+  }
+
+  get username() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["username"];
+  }
+
+  set username(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'username' property on 'URL': The provided value" });
+
+    this[impl]["username"] = V;
+  }
+
+  get password() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["password"];
+  }
+
+  set password(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'password' property on 'URL': The provided value" });
+
+    this[impl]["password"] = V;
+  }
+
+  get host() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["host"];
+  }
+
+  set host(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'host' property on 'URL': The provided value" });
+
+    this[impl]["host"] = V;
+  }
+
+  get hostname() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["hostname"];
+  }
+
+  set hostname(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'hostname' property on 'URL': The provided value" });
+
+    this[impl]["hostname"] = V;
+  }
+
+  get port() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["port"];
+  }
+
+  set port(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'port' property on 'URL': The provided value" });
+
+    this[impl]["port"] = V;
+  }
+
+  get pathname() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["pathname"];
+  }
+
+  set pathname(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'pathname' property on 'URL': The provided value" });
+
+    this[impl]["pathname"] = V;
+  }
+
+  get search() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["search"];
+  }
+
+  set search(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'search' property on 'URL': The provided value" });
+
+    this[impl]["search"] = V;
+  }
+
+  get searchParams() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return utils.getSameObject(this, "searchParams", () => {
+      return utils.tryWrapperForImpl(this[impl]["searchParams"]);
+    });
+  }
+
+  get hash() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["hash"];
+  }
+
+  set hash(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["USVString"](V, { context: "Failed to set the 'hash' property on 'URL': The provided value" });
+
+    this[impl]["hash"] = V;
+  }
+}
+Object.defineProperties(URL.prototype, {
+  toJSON: { enumerable: true },
+  href: { enumerable: true },
+  toString: { enumerable: true },
+  origin: { enumerable: true },
+  protocol: { enumerable: true },
+  username: { enumerable: true },
+  password: { enumerable: true },
+  host: { enumerable: true },
+  hostname: { enumerable: true },
+  port: { enumerable: true },
+  pathname: { enumerable: true },
+  search: { enumerable: true },
+  searchParams: { enumerable: true },
+  hash: { enumerable: true },
+  [Symbol.toStringTag]: { value: "URL", configurable: true }
+});
+const iface = {
+  // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+  // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+  // implementing this mixin interface.
+  _mixedIntoPredicates: [],
+  is(obj) {
+    if (obj) {
+      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+        return true;
+      }
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(obj)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+  isImpl(obj) {
+    if (obj) {
+      if (obj instanceof Impl.implementation) {
+        return true;
+      }
+
+      const wrapper = utils.wrapperForImpl(obj);
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(wrapper)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+  convert(obj, { context = "The provided value" } = {}) {
+    if (module.exports.is(obj)) {
+      return utils.implForWrapper(obj);
+    }
+    throw new TypeError(`${context} is not of type 'URL'.`);
+  },
+
+  create(constructorArgs, privateData) {
+    let obj = Object.create(URL.prototype);
+    obj = this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  createImpl(constructorArgs, privateData) {
+    let obj = Object.create(URL.prototype);
+    obj = this.setup(obj, constructorArgs, privateData);
+    return utils.implForWrapper(obj);
+  },
+  _internalSetup(obj) {},
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+
+    privateData.wrapper = obj;
+
+    this._internalSetup(obj);
+    Object.defineProperty(obj, impl, {
+      value: new Impl.implementation(constructorArgs, privateData),
+      configurable: true
+    });
+
+    obj[impl][utils.wrapperSymbol] = obj;
+    if (Impl.init) {
+      Impl.init(obj[impl], privateData);
+    }
+    return obj;
+  },
+  interface: URL,
+  expose: {
+    Window: { URL },
+    Worker: { URL }
+  }
+}; // iface
+module.exports = iface;
+
+const Impl = require("./URL-impl.js");

node_modules/data-urls/node_modules/whatwg-url/lib/URLSearchParams-impl.js

@@ -0,0 +1,122 @@
+"use strict";
+const stableSortBy = require("lodash.sortby");
+const urlencoded = require("./urlencoded");
+
+exports.implementation = class URLSearchParamsImpl {
+  constructor(constructorArgs, { doNotStripQMark = false }) {
+    let init = constructorArgs[0];
+    this._list = [];
+    this._url = null;
+
+    if (!doNotStripQMark && typeof init === "string" && init[0] === "?") {
+      init = init.slice(1);
+    }
+
+    if (Array.isArray(init)) {
+      for (const pair of init) {
+        if (pair.length !== 2) {
+          throw new TypeError("Failed to construct 'URLSearchParams': parameter 1 sequence's element does not " +
+                              "contain exactly two elements.");
+        }
+        this._list.push([pair[0], pair[1]]);
+      }
+    } else if (typeof init === "object" && Object.getPrototypeOf(init) === null) {
+      for (const name of Object.keys(init)) {
+        const value = init[name];
+        this._list.push([name, value]);
+      }
+    } else {
+      this._list = urlencoded.parseUrlencoded(init);
+    }
+  }
+
+  _updateSteps() {
+    if (this._url !== null) {
+      let query = urlencoded.serializeUrlencoded(this._list);
+      if (query === "") {
+        query = null;
+      }
+      this._url._url.query = query;
+    }
+  }
+
+  append(name, value) {
+    this._list.push([name, value]);
+    this._updateSteps();
+  }
+
+  delete(name) {
+    let i = 0;
+    while (i < this._list.length) {
+      if (this._list[i][0] === name) {
+        this._list.splice(i, 1);
+      } else {
+        i++;
+      }
+    }
+    this._updateSteps();
+  }
+
+  get(name) {
+    for (const tuple of this._list) {
+      if (tuple[0] === name) {
+        return tuple[1];
+      }
+    }
+    return null;
+  }
+
+  getAll(name) {
+    const output = [];
+    for (const tuple of this._list) {
+      if (tuple[0] === name) {
+        output.push(tuple[1]);
+      }
+    }
+    return output;
+  }
+
+  has(name) {
+    for (const tuple of this._list) {
+      if (tuple[0] === name) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  set(name, value) {
+    let found = false;
+    let i = 0;
+    while (i < this._list.length) {
+      if (this._list[i][0] === name) {
+        if (found) {
+          this._list.splice(i, 1);
+        } else {
+          found = true;
+          this._list[i][1] = value;
+          i++;
+        }
+      } else {
+        i++;
+      }
+    }
+    if (!found) {
+      this._list.push([name, value]);
+    }
+    this._updateSteps();
+  }
+
+  sort() {
+    this._list = stableSortBy(this._list, [0]);
+    this._updateSteps();
+  }
+
+  [Symbol.iterator]() {
+    return this._list[Symbol.iterator]();
+  }
+
+  toString() {
+    return urlencoded.serializeUrlencoded(this._list);
+  }
+};

node_modules/data-urls/node_modules/whatwg-url/lib/URLSearchParams.js

@@ -0,0 +1,432 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+
+const IteratorPrototype = Object.create(utils.IteratorPrototype, {
+  next: {
+    value: function next() {
+      const internal = this[utils.iterInternalSymbol];
+      const { target, kind, index } = internal;
+      const values = Array.from(target[impl]);
+      const len = values.length;
+      if (index >= len) {
+        return { value: undefined, done: true };
+      }
+
+      const pair = values[index];
+      internal.index = index + 1;
+      const [key, value] = pair.map(utils.tryWrapperForImpl);
+
+      let result;
+      switch (kind) {
+        case "key":
+          result = key;
+          break;
+        case "value":
+          result = value;
+          break;
+        case "key+value":
+          result = [key, value];
+          break;
+      }
+      return { value: result, done: false };
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  },
+  [Symbol.toStringTag]: {
+    value: "URLSearchParams Iterator",
+    configurable: true
+  }
+});
+class URLSearchParams {
+  constructor() {
+    const args = [];
+    {
+      let curArg = arguments[0];
+      if (curArg !== undefined) {
+        if (utils.isObject(curArg)) {
+          if (curArg[Symbol.iterator] !== undefined) {
+            if (!utils.isObject(curArg)) {
+              throw new TypeError(
+                "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + " is not an iterable object."
+              );
+            } else {
+              const V = [];
+              const tmp = curArg;
+              for (let nextItem of tmp) {
+                if (!utils.isObject(nextItem)) {
+                  throw new TypeError(
+                    "Failed to construct 'URLSearchParams': parameter 1" +
+                      " sequence" +
+                      "'s element" +
+                      " is not an iterable object."
+                  );
+                } else {
+                  const V = [];
+                  const tmp = nextItem;
+                  for (let nextItem of tmp) {
+                    nextItem = conversions["USVString"](nextItem, {
+                      context:
+                        "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + "'s element" + "'s element"
+                    });
+
+                    V.push(nextItem);
+                  }
+                  nextItem = V;
+                }
+
+                V.push(nextItem);
+              }
+              curArg = V;
+            }
+          } else {
+            if (!utils.isObject(curArg)) {
+              throw new TypeError(
+                "Failed to construct 'URLSearchParams': parameter 1" + " record" + " is not an object."
+              );
+            } else {
+              const result = Object.create(null);
+              for (const key of Reflect.ownKeys(curArg)) {
+                const desc = Object.getOwnPropertyDescriptor(curArg, key);
+                if (desc && desc.enumerable) {
+                  let typedKey = key;
+                  let typedValue = curArg[key];
+
+                  typedKey = conversions["USVString"](typedKey, {
+                    context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s key"
+                  });
+
+                  typedValue = conversions["USVString"](typedValue, {
+                    context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s value"
+                  });
+
+                  result[typedKey] = typedValue;
+                }
+              }
+              curArg = result;
+            }
+          }
+        } else {
+          curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URLSearchParams': parameter 1" });
+        }
+      } else {
+        curArg = "";
+      }
+      args.push(curArg);
+    }
+    return iface.setup(Object.create(new.target.prototype), args);
+  }
+
+  append(name, value) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 2) {
+      throw new TypeError(
+        "Failed to execute 'append' on 'URLSearchParams': 2 arguments required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'append' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    {
+      let curArg = arguments[1];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'append' on 'URLSearchParams': parameter 2"
+      });
+      args.push(curArg);
+    }
+    return this[impl].append(...args);
+  }
+
+  delete(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'delete' on 'URLSearchParams': 1 argument required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'delete' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].delete(...args);
+  }
+
+  get(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'get' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'get' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].get(...args);
+  }
+
+  getAll(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'getAll' on 'URLSearchParams': 1 argument required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return utils.tryWrapperForImpl(this[impl].getAll(...args));
+  }
+
+  has(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'has' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'has' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].has(...args);
+  }
+
+  set(name, value) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 2) {
+      throw new TypeError(
+        "Failed to execute 'set' on 'URLSearchParams': 2 arguments required, but only " + arguments.length + " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'set' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    {
+      let curArg = arguments[1];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'set' on 'URLSearchParams': parameter 2"
+      });
+      args.push(curArg);
+    }
+    return this[impl].set(...args);
+  }
+
+  sort() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl].sort();
+  }
+
+  toString() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl].toString();
+  }
+
+  keys() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "key");
+  }
+
+  values() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "value");
+  }
+
+  entries() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "key+value");
+  }
+
+  forEach(callback) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    if (arguments.length < 1) {
+      throw new TypeError("Failed to execute 'forEach' on 'iterable': 1 argument required, " + "but only 0 present.");
+    }
+    if (typeof callback !== "function") {
+      throw new TypeError(
+        "Failed to execute 'forEach' on 'iterable': The callback provided " + "as parameter 1 is not a function."
+      );
+    }
+    const thisArg = arguments[1];
+    let pairs = Array.from(this[impl]);
+    let i = 0;
+    while (i < pairs.length) {
+      const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
+      callback.call(thisArg, value, key, this);
+      pairs = Array.from(this[impl]);
+      i++;
+    }
+  }
+}
+Object.defineProperties(URLSearchParams.prototype, {
+  append: { enumerable: true },
+  delete: { enumerable: true },
+  get: { enumerable: true },
+  getAll: { enumerable: true },
+  has: { enumerable: true },
+  set: { enumerable: true },
+  sort: { enumerable: true },
+  toString: { enumerable: true },
+  keys: { enumerable: true },
+  values: { enumerable: true },
+  entries: { enumerable: true },
+  forEach: { enumerable: true },
+  [Symbol.toStringTag]: { value: "URLSearchParams", configurable: true },
+  [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }
+});
+const iface = {
+  // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+  // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+  // implementing this mixin interface.
+  _mixedIntoPredicates: [],
+  is(obj) {
+    if (obj) {
+      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+        return true;
+      }
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(obj)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+  isImpl(obj) {
+    if (obj) {
+      if (obj instanceof Impl.implementation) {
+        return true;
+      }
+
+      const wrapper = utils.wrapperForImpl(obj);
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(wrapper)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+  convert(obj, { context = "The provided value" } = {}) {
+    if (module.exports.is(obj)) {
+      return utils.implForWrapper(obj);
+    }
+    throw new TypeError(`${context} is not of type 'URLSearchParams'.`);
+  },
+
+  createDefaultIterator(target, kind) {
+    const iterator = Object.create(IteratorPrototype);
+    Object.defineProperty(iterator, utils.iterInternalSymbol, {
+      value: { target, kind, index: 0 },
+      configurable: true
+    });
+    return iterator;
+  },
+
+  create(constructorArgs, privateData) {
+    let obj = Object.create(URLSearchParams.prototype);
+    obj = this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  createImpl(constructorArgs, privateData) {
+    let obj = Object.create(URLSearchParams.prototype);
+    obj = this.setup(obj, constructorArgs, privateData);
+    return utils.implForWrapper(obj);
+  },
+  _internalSetup(obj) {},
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+
+    privateData.wrapper = obj;
+
+    this._internalSetup(obj);
+    Object.defineProperty(obj, impl, {
+      value: new Impl.implementation(constructorArgs, privateData),
+      configurable: true
+    });
+
+    obj[impl][utils.wrapperSymbol] = obj;
+    if (Impl.init) {
+      Impl.init(obj[impl], privateData);
+    }
+    return obj;
+  },
+  interface: URLSearchParams,
+  expose: {
+    Window: { URLSearchParams },
+    Worker: { URLSearchParams }
+  }
+}; // iface
+module.exports = iface;
+
+const Impl = require("./URLSearchParams-impl.js");

node_modules/data-urls/node_modules/whatwg-url/lib/infra.js

@@ -0,0 +1,24 @@
+"use strict";
+
+function isASCIIDigit(c) {
+  return c >= 0x30 && c <= 0x39;
+}
+
+function isASCIIAlpha(c) {
+  return (c >= 0x41 && c <= 0x5A) || (c >= 0x61 && c <= 0x7A);
+}
+
+function isASCIIAlphanumeric(c) {
+  return isASCIIAlpha(c) || isASCIIDigit(c);
+}
+
+function isASCIIHex(c) {
+  return isASCIIDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66);
+}
+
+module.exports = {
+  isASCIIDigit,
+  isASCIIAlpha,
+  isASCIIAlphanumeric,
+  isASCIIHex
+};

node_modules/data-urls/node_modules/whatwg-url/lib/public-api.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.URL = require("./URL").interface;
+exports.URLSearchParams = require("./URLSearchParams").interface;
+
+exports.parseURL = require("./url-state-machine").parseURL;
+exports.basicURLParse = require("./url-state-machine").basicURLParse;
+exports.serializeURL = require("./url-state-machine").serializeURL;
+exports.serializeHost = require("./url-state-machine").serializeHost;
+exports.serializeInteger = require("./url-state-machine").serializeInteger;
+exports.serializeURLOrigin = require("./url-state-machine").serializeURLOrigin;
+exports.setTheUsername = require("./url-state-machine").setTheUsername;
+exports.setThePassword = require("./url-state-machine").setThePassword;
+exports.cannotHaveAUsernamePasswordPort = require("./url-state-machine").cannotHaveAUsernamePasswordPort;
+
+exports.percentDecode = require("./urlencoded").percentDecode;

node_modules/data-urls/node_modules/whatwg-url/lib/urlencoded.js

@@ -0,0 +1,138 @@
+"use strict";
+const { isASCIIHex } = require("./infra");
+
+function strictlySplitByteSequence(buf, cp) {
+  const list = [];
+  let last = 0;
+  let i = buf.indexOf(cp);
+  while (i >= 0) {
+    list.push(buf.slice(last, i));
+    last = i + 1;
+    i = buf.indexOf(cp, last);
+  }
+  if (last !== buf.length) {
+    list.push(buf.slice(last));
+  }
+  return list;
+}
+
+function replaceByteInByteSequence(buf, from, to) {
+  let i = buf.indexOf(from);
+  while (i >= 0) {
+    buf[i] = to;
+    i = buf.indexOf(from, i + 1);
+  }
+  return buf;
+}
+
+function percentEncode(c) {
+  let hex = c.toString(16).toUpperCase();
+  if (hex.length === 1) {
+    hex = "0" + hex;
+  }
+
+  return "%" + hex;
+}
+
+function percentDecode(input) {
+  const output = Buffer.alloc(input.byteLength);
+  let ptr = 0;
+  for (let i = 0; i < input.length; ++i) {
+    if (input[i] !== 37 || !isASCIIHex(input[i + 1]) || !isASCIIHex(input[i + 2])) {
+      output[ptr++] = input[i];
+    } else {
+      output[ptr++] = parseInt(input.slice(i + 1, i + 3).toString(), 16);
+      i += 2;
+    }
+  }
+  return output.slice(0, ptr);
+}
+
+function parseUrlencoded(input) {
+  const sequences = strictlySplitByteSequence(input, 38);
+  const output = [];
+  for (const bytes of sequences) {
+    if (bytes.length === 0) {
+      continue;
+    }
+
+    let name;
+    let value;
+    const indexOfEqual = bytes.indexOf(61);
+
+    if (indexOfEqual >= 0) {
+      name = bytes.slice(0, indexOfEqual);
+      value = bytes.slice(indexOfEqual + 1);
+    } else {
+      name = bytes;
+      value = Buffer.alloc(0);
+    }
+
+    name = replaceByteInByteSequence(Buffer.from(name), 43, 32);
+    value = replaceByteInByteSequence(Buffer.from(value), 43, 32);
+
+    output.push([percentDecode(name).toString(), percentDecode(value).toString()]);
+  }
+  return output;
+}
+
+function serializeUrlencodedByte(input) {
+  let output = "";
+  for (const byte of input) {
+    if (byte === 32) {
+      output += "+";
+    } else if (byte === 42 ||
+               byte === 45 ||
+               byte === 46 ||
+               (byte >= 48 && byte <= 57) ||
+               (byte >= 65 && byte <= 90) ||
+               byte === 95 ||
+               (byte >= 97 && byte <= 122)) {
+      output += String.fromCodePoint(byte);
+    } else {
+      output += percentEncode(byte);
+    }
+  }
+  return output;
+}
+
+function serializeUrlencoded(tuples, encodingOverride = undefined) {
+  let encoding = "utf-8";
+  if (encodingOverride !== undefined) {
+    encoding = encodingOverride;
+  }
+
+  let output = "";
+  for (const [i, tuple] of tuples.entries()) {
+    // TODO: handle encoding override
+    const name = serializeUrlencodedByte(Buffer.from(tuple[0]));
+    let value = tuple[1];
+    if (tuple.length > 2 && tuple[2] !== undefined) {
+      if (tuple[2] === "hidden" && name === "_charset_") {
+        value = encoding;
+      } else if (tuple[2] === "file") {
+        // value is a File object
+        value = value.name;
+      }
+    }
+    value = serializeUrlencodedByte(Buffer.from(value));
+    if (i !== 0) {
+      output += "&";
+    }
+    output += `${name}=${value}`;
+  }
+  return output;
+}
+
+module.exports = {
+  percentEncode,
+  percentDecode,
+
+  // application/x-www-form-urlencoded string parser
+  parseUrlencoded(input) {
+    return parseUrlencoded(Buffer.from(input));
+  },
+
+  // application/x-www-form-urlencoded serializer
+  serializeUrlencoded
+};

node_modules/data-urls/node_modules/whatwg-url/lib/utils.js

@@ -0,0 +1,127 @@
+"use strict";
+
+// Returns "Type(value) is Object" in ES terminology.
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+const getOwnPropertyDescriptors = typeof Object.getOwnPropertyDescriptors === "function" ?
+  Object.getOwnPropertyDescriptors :
+  // Polyfill exists until we require Node.js v8.x
+  // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors
+  obj => {
+    if (obj === undefined || obj === null) {
+      throw new TypeError("Cannot convert undefined or null to object");
+    }
+    obj = Object(obj);
+    const ownKeys = Reflect.ownKeys(obj);
+    const descriptors = {};
+    for (const key of ownKeys) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(obj, key);
+      if (descriptor !== undefined) {
+        Reflect.defineProperty(descriptors, key, {
+          value: descriptor,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return descriptors;
+  };
+
+const wrapperSymbol = Symbol("wrapper");
+const implSymbol = Symbol("impl");
+const sameObjectCaches = Symbol("SameObject caches");
+
+function getSameObject(wrapper, prop, creator) {
+  if (!wrapper[sameObjectCaches]) {
+    wrapper[sameObjectCaches] = Object.create(null);
+  }
+
+  if (prop in wrapper[sameObjectCaches]) {
+    return wrapper[sameObjectCaches][prop];
+  }
+
+  wrapper[sameObjectCaches][prop] = creator();
+  return wrapper[sameObjectCaches][prop];
+}
+
+function wrapperForImpl(impl) {
+  return impl ? impl[wrapperSymbol] : null;
+}
+
+function implForWrapper(wrapper) {
+  return wrapper ? wrapper[implSymbol] : null;
+}
+
+function tryWrapperForImpl(impl) {
+  const wrapper = wrapperForImpl(impl);
+  return wrapper ? wrapper : impl;
+}
+
+function tryImplForWrapper(wrapper) {
+  const impl = implForWrapper(wrapper);
+  return impl ? impl : wrapper;
+}
+
+const iterInternalSymbol = Symbol("internal");
+const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+
+function isArrayIndexPropName(P) {
+  if (typeof P !== "string") {
+    return false;
+  }
+  const i = P >>> 0;
+  if (i === Math.pow(2, 32) - 1) {
+    return false;
+  }
+  const s = `${i}`;
+  if (P !== s) {
+    return false;
+  }
+  return true;
+}
+
+const supportsPropertyIndex = Symbol("supports property index");
+const supportedPropertyIndices = Symbol("supported property indices");
+const supportsPropertyName = Symbol("supports property name");
+const supportedPropertyNames = Symbol("supported property names");
+const indexedGet = Symbol("indexed property get");
+const indexedSetNew = Symbol("indexed property set new");
+const indexedSetExisting = Symbol("indexed property set existing");
+const namedGet = Symbol("named property get");
+const namedSetNew = Symbol("named property set new");
+const namedSetExisting = Symbol("named property set existing");
+const namedDelete = Symbol("named property delete");
+
+module.exports = exports = {
+  isObject,
+  hasOwn,
+  getOwnPropertyDescriptors,
+  wrapperSymbol,
+  implSymbol,
+  getSameObject,
+  wrapperForImpl,
+  implForWrapper,
+  tryWrapperForImpl,
+  tryImplForWrapper,
+  iterInternalSymbol,
+  IteratorPrototype,
+  isArrayIndexPropName,
+  supportsPropertyIndex,
+  supportedPropertyIndices,
+  supportsPropertyName,
+  supportedPropertyNames,
+  indexedGet,
+  indexedSetNew,
+  indexedSetExisting,
+  namedGet,
+  namedSetNew,
+  namedSetExisting,
+  namedDelete
+};

node_modules/data-urls/node_modules/whatwg-url/package.json

@@ -0,0 +1,90 @@
+{
+  "_from": "whatwg-url@^7.0.0",
+  "_id": "whatwg-url@7.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-37GeVSIJ3kn1JgKyjiYNmSLP1yzbpb29jdmwBSgkD9h40/hyrR/OifpVUndji3tmwGgD8qpw7iQu3RSbCrBpsQ==",
+  "_location": "/data-urls/whatwg-url",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "whatwg-url@^7.0.0",
+    "name": "whatwg-url",
+    "escapedName": "whatwg-url",
+    "rawSpec": "^7.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.0.0"
+  },
+  "_requiredBy": [
+    "/data-urls"
+  ],
+  "_resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.0.0.tgz",
+  "_shasum": "fde926fa54a599f3adf82dff25a9f7be02dc6edd",
+  "_spec": "whatwg-url@^7.0.0",
+  "_where": "E:\\github\\setup-java\\node_modules\\data-urls",
+  "author": {
+    "name": "Sebastian Mayr",
+    "email": "github@smayr.name"
+  },
+  "bugs": {
+    "url": "https://github.com/jsdom/whatwg-url/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "lodash.sortby": "^4.7.0",
+    "tr46": "^1.0.1",
+    "webidl-conversions": "^4.0.2"
+  },
+  "deprecated": false,
+  "description": "An implementation of the WHATWG URL Standard's URL API and parsing machinery",
+  "devDependencies": {
+    "browserify": "^16.2.2",
+    "domexception": "^1.0.1",
+    "eslint": "^5.4.0",
+    "jest": "^23.5.0",
+    "jsdom": "^11.12.0",
+    "recast": "^0.15.3",
+    "request": "^2.88.0",
+    "webidl2js": "^9.0.1"
+  },
+  "files": [
+    "lib/"
+  ],
+  "homepage": "https://github.com/jsdom/whatwg-url#readme",
+  "jest": {
+    "collectCoverageFrom": [
+      "lib/**/*.js",
+      "!lib/utils.js"
+    ],
+    "coverageDirectory": "coverage",
+    "coverageReporters": [
+      "lcov",
+      "text-summary"
+    ],
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/test/**/*.js"
+    ],
+    "testPathIgnorePatterns": [
+      "^<rootDir>/test/testharness.js$",
+      "^<rootDir>/test/web-platform-tests/"
+    ]
+  },
+  "license": "MIT",
+  "main": "lib/public-api.js",
+  "name": "whatwg-url",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsdom/whatwg-url.git"
+  },
+  "scripts": {
+    "build": "node scripts/transform.js && node scripts/convert-idl.js",
+    "build-live-viewer": "browserify lib/public-api.js --standalone whatwgURL > live-viewer/whatwg-url.js",
+    "coverage": "jest --coverage",
+    "lint": "eslint .",
+    "prepublish": "node scripts/transform.js && node scripts/convert-idl.js",
+    "pretest": "node scripts/get-latest-platform-tests.js && node scripts/transform.js && node scripts/convert-idl.js",
+    "test": "jest"
+  },
+  "version": "7.0.0"
+}

node_modules/data-urls/package.json

@@ -0,0 +1,90 @@
+{
+  "_from": "data-urls@^1.0.0",
+  "_id": "data-urls@1.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-YTWYI9se1P55u58gL5GkQHW4P6VJBJ5iBT+B5a7i2Tjadhv52paJG0qHX4A0OR6/t52odI64KP2YvFpkDOi3eQ==",
+  "_location": "/data-urls",
+  "_phantomChildren": {
+    "lodash.sortby": "4.7.0",
+    "tr46": "1.0.1",
+    "webidl-conversions": "4.0.2"
+  },
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "data-urls@^1.0.0",
+    "name": "data-urls",
+    "escapedName": "data-urls",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/jsdom"
+  ],
+  "_resolved": "https://registry.npmjs.org/data-urls/-/data-urls-1.1.0.tgz",
+  "_shasum": "15ee0582baa5e22bb59c77140da8f9c76963bbfe",
+  "_spec": "data-urls@^1.0.0",
+  "_where": "E:\\github\\setup-java\\node_modules\\jsdom",
+  "author": {
+    "name": "Domenic Denicola",
+    "email": "d@domenic.me",
+    "url": "https://domenic.me/"
+  },
+  "bugs": {
+    "url": "https://github.com/jsdom/data-urls/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "abab": "^2.0.0",
+    "whatwg-mimetype": "^2.2.0",
+    "whatwg-url": "^7.0.0"
+  },
+  "deprecated": false,
+  "description": "Parses data: URLs",
+  "devDependencies": {
+    "eslint": "^5.7.0",
+    "jest": "^23.6.0",
+    "request": "^2.88.0"
+  },
+  "files": [
+    "lib/"
+  ],
+  "homepage": "https://github.com/jsdom/data-urls#readme",
+  "jest": {
+    "coverageDirectory": "coverage",
+    "coverageReporters": [
+      "lcov",
+      "text-summary"
+    ],
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/test/**/*.js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "<rootDir>/node_modules/(?!(abab/lib/atob.js))"
+    ]
+  },
+  "keywords": [
+    "data url",
+    "data uri",
+    "data:",
+    "http",
+    "fetch",
+    "whatwg"
+  ],
+  "license": "MIT",
+  "main": "lib/parser.js",
+  "name": "data-urls",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsdom/data-urls.git"
+  },
+  "scripts": {
+    "coverage": "jest --coverage",
+    "lint": "eslint .",
+    "pretest": "node scripts/get-latest-platform-tests.js",
+    "test": "jest"
+  },
+  "version": "1.1.0"
+}