update node modules

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

@@ -1,217 +0,0 @@
-"use strict";
-const usm = require("./url-state-machine");
-const urlencoded = require("./urlencoded");
-const URLSearchParams = require("./URLSearchParams");
-
-exports.implementation = class URLImpl {
-  constructor(globalObject, 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(globalObject, [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/whatwg-url/lib/URL.js

@@ -1,363 +0,0 @@
-"use strict";
-
-const conversions = require("webidl-conversions");
-const utils = require("./utils.js");
-
-const impl = utils.implSymbol;
-const ctorRegistry = utils.ctorRegistrySymbol;
-
-const interfaceName = "URL";
-
-/**
- * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
- * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
- * implementing this mixin interface.
- */
-exports._mixedIntoPredicates = [];
-exports.is = function is(obj) {
-  if (obj) {
-    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
-      return true;
-    }
-    for (const isMixedInto of exports._mixedIntoPredicates) {
-      if (isMixedInto(obj)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-exports.isImpl = function isImpl(obj) {
-  if (obj) {
-    if (obj instanceof Impl.implementation) {
-      return true;
-    }
-
-    const wrapper = utils.wrapperForImpl(obj);
-    for (const isMixedInto of exports._mixedIntoPredicates) {
-      if (isMixedInto(wrapper)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-exports.convert = function convert(obj, { context = "The provided value" } = {}) {
-  if (exports.is(obj)) {
-    return utils.implForWrapper(obj);
-  }
-  throw new TypeError(`${context} is not of type 'URL'.`);
-};
-
-exports.create = function create(globalObject, constructorArgs, privateData) {
-  if (globalObject[ctorRegistry] === undefined) {
-    throw new Error("Internal error: invalid global object");
-  }
-
-  const ctor = globalObject[ctorRegistry]["URL"];
-  if (ctor === undefined) {
-    throw new Error("Internal error: constructor URL is not installed on the passed global object");
-  }
-
-  let obj = Object.create(ctor.prototype);
-  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
-  return obj;
-};
-exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
-  const obj = exports.create(globalObject, constructorArgs, privateData);
-  return utils.implForWrapper(obj);
-};
-exports._internalSetup = function _internalSetup(obj) {};
-exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
-  privateData.wrapper = obj;
-
-  exports._internalSetup(obj);
-  Object.defineProperty(obj, impl, {
-    value: new Impl.implementation(globalObject, constructorArgs, privateData),
-    configurable: true
-  });
-
-  obj[impl][utils.wrapperSymbol] = obj;
-  if (Impl.init) {
-    Impl.init(obj[impl], privateData);
-  }
-  return obj;
-};
-
-exports.install = function install(globalObject) {
-  class 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 exports.setup(Object.create(new.target.prototype), globalObject, args);
-    }
-
-    toJSON() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl].toJSON();
-    }
-
-    get href() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["href"];
-    }
-
-    set href(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, { context: "Failed to set the 'href' property on 'URL': The provided value" });
-
-      this[impl]["href"] = V;
-    }
-
-    toString() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-      return this[impl]["href"];
-    }
-
-    get origin() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["origin"];
-    }
-
-    get protocol() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["protocol"];
-    }
-
-    set protocol(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, {
-        context: "Failed to set the 'protocol' property on 'URL': The provided value"
-      });
-
-      this[impl]["protocol"] = V;
-    }
-
-    get username() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["username"];
-    }
-
-    set username(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, {
-        context: "Failed to set the 'username' property on 'URL': The provided value"
-      });
-
-      this[impl]["username"] = V;
-    }
-
-    get password() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["password"];
-    }
-
-    set password(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, {
-        context: "Failed to set the 'password' property on 'URL': The provided value"
-      });
-
-      this[impl]["password"] = V;
-    }
-
-    get host() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["host"];
-    }
-
-    set host(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, { context: "Failed to set the 'host' property on 'URL': The provided value" });
-
-      this[impl]["host"] = V;
-    }
-
-    get hostname() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["hostname"];
-    }
-
-    set hostname(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, {
-        context: "Failed to set the 'hostname' property on 'URL': The provided value"
-      });
-
-      this[impl]["hostname"] = V;
-    }
-
-    get port() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["port"];
-    }
-
-    set port(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, { context: "Failed to set the 'port' property on 'URL': The provided value" });
-
-      this[impl]["port"] = V;
-    }
-
-    get pathname() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["pathname"];
-    }
-
-    set pathname(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, {
-        context: "Failed to set the 'pathname' property on 'URL': The provided value"
-      });
-
-      this[impl]["pathname"] = V;
-    }
-
-    get search() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["search"];
-    }
-
-    set search(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, { context: "Failed to set the 'search' property on 'URL': The provided value" });
-
-      this[impl]["search"] = V;
-    }
-
-    get searchParams() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return utils.getSameObject(this, "searchParams", () => {
-        return utils.tryWrapperForImpl(this[impl]["searchParams"]);
-      });
-    }
-
-    get hash() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl]["hash"];
-    }
-
-    set hash(V) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      V = conversions["USVString"](V, { context: "Failed to set the 'hash' property on '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 }
-  });
-  if (globalObject[ctorRegistry] === undefined) {
-    globalObject[ctorRegistry] = Object.create(null);
-  }
-  globalObject[ctorRegistry][interfaceName] = URL;
-
-  Object.defineProperty(globalObject, interfaceName, {
-    configurable: true,
-    writable: true,
-    value: URL
-  });
-};
-
-const Impl = require("./URL-impl.js");

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

@@ -1,122 +0,0 @@
-"use strict";
-const stableSortBy = require("lodash.sortby");
-const urlencoded = require("./urlencoded");
-
-exports.implementation = class URLSearchParamsImpl {
-  constructor(globalObject, 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/whatwg-url/lib/URLSearchParams.js

@@ -1,461 +0,0 @@
-"use strict";
-
-const conversions = require("webidl-conversions");
-const utils = require("./utils.js");
-
-const impl = utils.implSymbol;
-const ctorRegistry = utils.ctorRegistrySymbol;
-
-const interfaceName = "URLSearchParams";
-
-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
-  }
-});
-
-/**
- * When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
- * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
- * implementing this mixin interface.
- */
-exports._mixedIntoPredicates = [];
-exports.is = function is(obj) {
-  if (obj) {
-    if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
-      return true;
-    }
-    for (const isMixedInto of exports._mixedIntoPredicates) {
-      if (isMixedInto(obj)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-exports.isImpl = function isImpl(obj) {
-  if (obj) {
-    if (obj instanceof Impl.implementation) {
-      return true;
-    }
-
-    const wrapper = utils.wrapperForImpl(obj);
-    for (const isMixedInto of exports._mixedIntoPredicates) {
-      if (isMixedInto(wrapper)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-exports.convert = function convert(obj, { context = "The provided value" } = {}) {
-  if (exports.is(obj)) {
-    return utils.implForWrapper(obj);
-  }
-  throw new TypeError(`${context} is not of type 'URLSearchParams'.`);
-};
-
-exports.createDefaultIterator = function createDefaultIterator(target, kind) {
-  const iterator = Object.create(IteratorPrototype);
-  Object.defineProperty(iterator, utils.iterInternalSymbol, {
-    value: { target, kind, index: 0 },
-    configurable: true
-  });
-  return iterator;
-};
-
-exports.create = function create(globalObject, constructorArgs, privateData) {
-  if (globalObject[ctorRegistry] === undefined) {
-    throw new Error("Internal error: invalid global object");
-  }
-
-  const ctor = globalObject[ctorRegistry]["URLSearchParams"];
-  if (ctor === undefined) {
-    throw new Error("Internal error: constructor URLSearchParams is not installed on the passed global object");
-  }
-
-  let obj = Object.create(ctor.prototype);
-  obj = exports.setup(obj, globalObject, constructorArgs, privateData);
-  return obj;
-};
-exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
-  const obj = exports.create(globalObject, constructorArgs, privateData);
-  return utils.implForWrapper(obj);
-};
-exports._internalSetup = function _internalSetup(obj) {};
-exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
-  privateData.wrapper = obj;
-
-  exports._internalSetup(obj);
-  Object.defineProperty(obj, impl, {
-    value: new Impl.implementation(globalObject, constructorArgs, privateData),
-    configurable: true
-  });
-
-  obj[impl][utils.wrapperSymbol] = obj;
-  if (Impl.init) {
-    Impl.init(obj[impl], privateData);
-  }
-  return obj;
-};
-
-exports.install = function install(globalObject) {
-  class 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;
-
-                    typedKey = conversions["USVString"](typedKey, {
-                      context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s key"
-                    });
-
-                    let typedValue = curArg[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 exports.setup(Object.create(new.target.prototype), globalObject, args);
-    }
-
-    append(name, value) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      if (arguments.length < 2) {
-        throw new TypeError(
-          "Failed to execute 'append' on '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 || !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 || !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 || !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 || !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 || !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 || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl].sort();
-    }
-
-    toString() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-
-      return this[impl].toString();
-    }
-
-    keys() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-      return exports.createDefaultIterator(this, "key");
-    }
-
-    values() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-      return exports.createDefaultIterator(this, "value");
-    }
-
-    entries() {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-      return exports.createDefaultIterator(this, "key+value");
-    }
-
-    forEach(callback) {
-      if (!this || !exports.is(this)) {
-        throw new TypeError("Illegal invocation");
-      }
-      if (arguments.length < 1) {
-        throw new TypeError("Failed to execute 'forEach' on 'iterable': 1 argument required, " + "but only 0 present.");
-      }
-      if (typeof callback !== "function") {
-        throw new TypeError(
-          "Failed to execute 'forEach' on 'iterable': The callback provided " + "as parameter 1 is not a function."
-        );
-      }
-      const thisArg = arguments[1];
-      let pairs = Array.from(this[impl]);
-      let i = 0;
-      while (i < pairs.length) {
-        const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
-        callback.call(thisArg, value, key, this);
-        pairs = Array.from(this[impl]);
-        i++;
-      }
-    }
-  }
-  Object.defineProperties(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 }
-  });
-  if (globalObject[ctorRegistry] === undefined) {
-    globalObject[ctorRegistry] = Object.create(null);
-  }
-  globalObject[ctorRegistry][interfaceName] = URLSearchParams;
-
-  Object.defineProperty(globalObject, interfaceName, {
-    configurable: true,
-    writable: true,
-    value: URLSearchParams
-  });
-};
-
-const Impl = require("./URLSearchParams-impl.js");

node_modules/whatwg-url/lib/infra.js

@@ -1,24 +0,0 @@
-"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/whatwg-url/lib/urlencoded.js

@@ -1,138 +0,0 @@
-"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/whatwg-url/lib/utils.js

@@ -1,115 +0,0 @@
-"use strict";
-
-// Returns "Type(value) is Object" in ES terminology.
-function isObject(value) {
-  return typeof value === "object" && value !== null || typeof value === "function";
-}
-
-function hasOwn(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-const wrapperSymbol = Symbol("wrapper");
-const implSymbol = Symbol("impl");
-const sameObjectCaches = Symbol("SameObject caches");
-const ctorRegistrySymbol = Symbol.for("[webidl2js]  constructor registry");
-
-function getSameObject(wrapper, prop, creator) {
-  if (!wrapper[sameObjectCaches]) {
-    wrapper[sameObjectCaches] = Object.create(null);
-  }
-
-  if (prop in wrapper[sameObjectCaches]) {
-    return wrapper[sameObjectCaches][prop];
-  }
-
-  wrapper[sameObjectCaches][prop] = creator();
-  return wrapper[sameObjectCaches][prop];
-}
-
-function wrapperForImpl(impl) {
-  return impl ? impl[wrapperSymbol] : null;
-}
-
-function implForWrapper(wrapper) {
-  return wrapper ? wrapper[implSymbol] : null;
-}
-
-function tryWrapperForImpl(impl) {
-  const wrapper = wrapperForImpl(impl);
-  return wrapper ? wrapper : impl;
-}
-
-function tryImplForWrapper(wrapper) {
-  const impl = implForWrapper(wrapper);
-  return impl ? impl : wrapper;
-}
-
-const iterInternalSymbol = Symbol("internal");
-const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
-
-function isArrayIndexPropName(P) {
-  if (typeof P !== "string") {
-    return false;
-  }
-  const i = P >>> 0;
-  if (i === Math.pow(2, 32) - 1) {
-    return false;
-  }
-  const s = `${i}`;
-  if (P !== s) {
-    return false;
-  }
-  return true;
-}
-
-const byteLengthGetter =
-    Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
-function isArrayBuffer(value) {
-  try {
-    byteLengthGetter.call(value);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-const supportsPropertyIndex = Symbol("supports property index");
-const supportedPropertyIndices = Symbol("supported property indices");
-const supportsPropertyName = Symbol("supports property name");
-const supportedPropertyNames = Symbol("supported property names");
-const indexedGet = Symbol("indexed property get");
-const indexedSetNew = Symbol("indexed property set new");
-const indexedSetExisting = Symbol("indexed property set existing");
-const namedGet = Symbol("named property get");
-const namedSetNew = Symbol("named property set new");
-const namedSetExisting = Symbol("named property set existing");
-const namedDelete = Symbol("named property delete");
-
-module.exports = exports = {
-  isObject,
-  hasOwn,
-  wrapperSymbol,
-  implSymbol,
-  getSameObject,
-  ctorRegistrySymbol,
-  wrapperForImpl,
-  implForWrapper,
-  tryWrapperForImpl,
-  tryImplForWrapper,
-  iterInternalSymbol,
-  IteratorPrototype,
-  isArrayBuffer,
-  isArrayIndexPropName,
-  supportsPropertyIndex,
-  supportedPropertyIndices,
-  supportsPropertyName,
-  supportedPropertyNames,
-  indexedGet,
-  indexedSetNew,
-  indexedSetExisting,
-  namedGet,
-  namedSetNew,
-  namedSetExisting,
-  namedDelete
-};