Initial commit

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/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/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,46 @@
+{
+  "name": "whatwg-url",
+  "version": "7.0.0",
+  "description": "An implementation of the WHATWG URL Standard's URL API and parsing machinery",
+  "main": "lib/public-api.js",
+  "files": [
+    "lib/"
+  ],
+  "author": "Sebastian Mayr <github@smayr.name>",
+  "license": "MIT",
+  "repository": "jsdom/whatwg-url",
+  "dependencies": {
+    "lodash.sortby": "^4.7.0",
+    "tr46": "^1.0.1",
+    "webidl-conversions": "^4.0.2"
+  },
+  "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"
+  },
+  "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/"
+    ]
+  }
+}

node_modules/data-urls/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "data-urls",
+  "description": "Parses data: URLs",
+  "version": "1.0.1",
+  "author": "Domenic Denicola <d@domenic.me> (https://domenic.me/)",
+  "license": "MIT",
+  "repository": "jsdom/data-urls",
+  "main": "lib/parser.js",
+  "files": [
+    "lib/"
+  ],
+  "devDependencies": {
+    "eslint": "^5.4.0",
+    "jest": "^23.5.0",
+    "request": "^2.88.0"
+  },
+  "jest": {
+    "coverageDirectory": "coverage",
+    "coverageReporters": [
+      "lcov",
+      "text-summary"
+    ],
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/test/**/*.js"
+    ]
+  },
+  "dependencies": {
+    "abab": "^2.0.0",
+    "whatwg-mimetype": "^2.1.0",
+    "whatwg-url": "^7.0.0"
+  }
+}