This PR will allow us to finally release a v2 of stardog.js. I'm putting it up now mainly for discussion, though if we decide that it's mergeable as-is, that's fine too. I'll try to highlight the major changes.

1. TypeScript instead of JavaScript. This allows us to:
   i. auto-generate the documentation,
   ii. prevent the types from falling out-of-sync with code, as they have before,
   iii. (hopefully) have a better development experience overall. The repo enforces noImplicitAny, so types are everywhere. This will close Move to TypeScript #161.
2. Named API arguments, instead of functions with many unnamed parameters, where order matters and you have to remember which is which, etc. This will close API change: from arbitrary function arguments to objects with named properties #159.
3. Standardization around import instead of require for importing modules. This aligns stardog.js more with the overall ecosystem, and prevents having to switch code styles as much between our repos. This will close Fix tests when using Stardog 6.0.1 #183.
4. The native fetch results are now exposed directly to the consumer. This will help us to stop adding hacks to stardog.js to aid Stardog Studio, where we sometimes need those results. (For users who still want the convenience of a transformed response, the httpBody method is now exposed on utils; we may also want to add a config setting that will always apply that transform, if the user desires).
5. Hard dependencies on fetch polyfills are removed, though of course they may be added. This also lets us avoid a bunch of hacks in Stardog Studio (e.g., when we want to fetch in Electron); the same hacks will be unnecessary for other consumers.
6. The code is made much cleaner (IMO) and reduces a lot of boilerplate. It becomes quite obvious that stardog.js is mostly just a wrapper around fetch, tailor-made for Stardog. As one example, this:

const getAll = (conn, database) => {
  const headers = conn.headers();
  return dispatchDBOptions(conn, {
    headers,
    database,
    method: 'GET',
  })
    .then(httpBody)
    .then(res => {
      if (res.status === 200) {
        return Object.assign({}, res, {
          body: flat.unflatten(res.body),
        });
      }
      return res;
    });
};

becomes this:

export const getAll = ({ connection, database }: Parameters<typeof get>[0]) =>
  get({
    connection,
    database,
    optionsToGet: null,
    method: RequestMethod.GET,
  });

Just about all of the source code consists of exports of wrappers like this.
7. Via TypeScript, tons of "magic string" parameters are now enum members (e.g., RequestMethod, ContentType, RequestHeader, etc.). This provides both type safety and more autocompletion.

Together, these changes also close #194.

There are probably other relevant things that I'm not thinking of right now. The most painful part of all this is likely to be the named argument changes, which will require lots of (albeit trivial) changes in Stardog Studio. But we can address that when the time comes.

Feel free to try this branch out, fire away with comments, pain points, etc.