Add node modules and compiled JavaScript from main (#54)

Co-authored-by: Oliver King <oking3@uncc.edu>

node_modules/tmp-promise/.circleci/config.yml

@@ -0,0 +1,53 @@
+version: 2
+
+common_steps: &common_steps
+    steps:
+      - checkout
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Run tests
+          command: npm run mocha
+
+      - run:
+          name: Check Typescript types
+          command: npm run check-types
+          when: always
+
+jobs:
+  node-8:
+    docker:
+      - image: circleci/node:8
+
+    <<: *common_steps
+
+  node-10:
+    docker:
+      - image: circleci/node:10
+
+    <<: *common_steps
+
+  node-11:
+    docker:
+      - image: circleci/node:11
+
+    <<: *common_steps
+
+  node-12:
+    docker:
+      - image: circleci/node:12
+
+    <<: *common_steps
+
+workflows:
+  version: 2
+
+  on-commit:
+    jobs:
+      - node-8
+      - node-10
+      - node-11
+      - node-12

node_modules/tmp-promise/README.md

@@ -0,0 +1,316 @@
+# tmp-promise
+
+[![CircleCI](https://circleci.com/gh/benjamingr/tmp-promise.svg?style=svg)](https://circleci.com/gh/benjamingr/tmp-promise)
+[![npm version](https://badge.fury.io/js/tmp-promise.svg)](https://badge.fury.io/js/tmp-promise)
+
+A simple utility for creating temporary files or directories.
+
+The [tmp](https://github.com/raszi/node-tmp) package with promises support. If you want to use `tmp` with `async/await` then this helper might be for you.
+
+This documentation is mostly copied from that package's - but with promise usage instead of callback usage adapted.
+
+## Installation
+
+    npm i tmp-promise
+
+**Note:** Node.js 8+ is supported - older versions of Node.js are not supported by the Node.js foundation. If you need to use an older version of Node.js install tmp-promise@1.10
+
+    npm i tmp-promise@1.1.0
+
+## About
+
+This adds promises support to a [widely used library][2]. This package is used to create temporary files and directories in a [Node.js][1] environment.
+ 
+
+tmp-promise offers both an asynchronous and a synchronous API. For all API calls, all
+the parameters are optional.
+
+Internally, tmp uses crypto for determining random file names, or, when using templates, a six letter random identifier. And just in case that you do not have that much entropy left on your system, tmp will fall back to pseudo random numbers.
+
+You can set whether you want to remove the temporary file on process exit or not, and the destination directory can also be set.
+
+tmp-promise also uses promise [disposers](http://stackoverflow.com/questions/28915677/what-is-the-promise-disposer-pattern) to provide a nice way to perform cleanup when you're done working with the files.
+
+## Usage (API Reference)
+
+### Asynchronous file creation
+
+Simple temporary file creation, the file will be closed and unlinked on process exit.
+
+With Node.js 10 and es - modules:
+
+```js
+import { file } from 'tmp-promise'
+
+(async () => {
+  const {fd, path, cleanup} = await file();
+  // work with file here in fd
+  cleanup();
+})(); 
+```
+
+Or the older way:
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.file().then(o => {  
+  console.log("File: ", o.path);
+  console.log("Filedescriptor: ", o.fd);
+  
+  // If we don't need the file anymore we could manually call cleanup
+  // But that is not necessary if we didn't pass the keep option because the library
+  // will clean after itself.
+  o.cleanup();
+});
+```
+
+Simple temporary file creation with a [disposer](http://stackoverflow.com/questions/28915677/what-is-the-promise-disposer-pattern):
+
+With Node.js 10 and es - modules:
+
+```js
+import { withFile } from 'tmp-promise'
+
+withFile(async ({path, fd}) => {
+  // when this function returns or throws - release the file 
+  await doSomethingWithFile(db);
+});
+```
+
+Or the older way:
+
+```js
+tmp.withFile(o => {
+  console.log("File: ", o.path);
+  console.log("Filedescriptor: ", o.fd);
+  // the file remains opens until the below promise resolves
+  return somePromiseReturningFn();
+}).then(v => {
+  // file is closed here automatically, v is the value of somePromiseReturningFn
+});
+```
+
+
+### Synchronous file creation
+
+A synchronous version of the above.
+
+```javascript
+var tmp = require('tmp-promise');
+
+var tmpobj = tmp.fileSync();
+console.log("File: ", tmpobj.name);
+console.log("Filedescriptor: ", tmpobj.fd);
+  
+// If we don't need the file anymore we could manually call the removeCallback
+// But that is not necessary if we didn't pass the keep option because the library
+// will clean after itself.
+tmpobj.removeCallback();
+```
+
+Note that this might throw an exception if either the maximum limit of retries
+for creating a temporary name fails, or, in case that you do not have the permission
+to write to the directory where the temporary file should be created in.
+
+### Asynchronous directory creation
+
+Simple temporary directory creation, it will be removed on process exit.
+
+If the directory still contains items on process exit, then it won't be removed.
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.dir().then(o => {
+  console.log("Dir: ", o.path);
+  
+  // Manual cleanup
+  o.cleanup();
+});
+```
+
+If you want to cleanup the directory even when there are entries in it, then
+you can pass the `unsafeCleanup` option when creating it.
+
+You can also use a [disposer](http://stackoverflow.com/questions/28915677/what-is-the-promise-disposer-pattern) here which takes care of cleanup automatically: 
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.withDir(o => {
+  console.log("Dir: ", o.path);
+  
+  // automatic cleanup when the below promise resolves
+  return somePromiseReturningFn(); 
+}).then(v => {
+  // the directory has been cleaned here
+});
+```
+
+### Synchronous directory creation
+
+A synchronous version of the above.
+
+```javascript
+var tmp = require('tmp-promise');
+
+var tmpobj = tmp.dirSync();
+console.log("Dir: ", tmpobj.name);
+// Manual cleanup
+tmpobj.removeCallback();
+```
+
+Note that this might throw an exception if either the maximum limit of retries
+for creating a temporary name fails, or, in case that you do not have the permission
+to write to the directory where the temporary directory should be created in.
+
+### Asynchronous filename generation
+
+It is possible with this library to generate a unique filename in the specified
+directory.
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.tmpName().then(path => {
+    console.log("Created temporary filename: ", path);
+});
+```
+
+### Synchronous filename generation
+
+A synchronous version of the above.
+
+```javascript
+var tmp = require('tmp-promise');
+
+var name = tmp.tmpNameSync();
+console.log("Created temporary filename: ", name);
+```
+
+## Advanced usage
+
+### Asynchronous file creation
+
+Creates a file with mode `0644`, prefix will be `prefix-` and postfix will be `.txt`.
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.file({ mode: 0644, prefix: 'prefix-', postfix: '.txt' }).then(o => {
+  console.log("File: ", o.path);
+  console.log("Filedescriptor: ", o.fd); 
+});
+```
+
+### Synchronous file creation
+
+A synchronous version of the above.
+
+```javascript
+var tmp = require('tmp-promise');
+
+var tmpobj = tmp.fileSync({ mode: 0644, prefix: 'prefix-', postfix: '.txt' });
+console.log("File: ", tmpobj.name);
+console.log("Filedescriptor: ", tmpobj.fd);
+```
+
+### Asynchronous directory creation
+
+Creates a directory with mode `0755`, prefix will be `myTmpDir_`.
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.dir({ mode: 0750, prefix: 'myTmpDir_' }).then(o => {
+  console.log("Dir: ", o.path);
+});
+```
+
+### Synchronous directory creation
+
+Again, a synchronous version of the above.
+
+```javascript
+var tmp = require('tmp-promise');
+
+var tmpobj = tmp.dirSync({ mode: 0750, prefix: 'myTmpDir_' });
+console.log("Dir: ", tmpobj.name);
+```
+
+
+### mkstemp like, asynchronously
+
+Creates a new temporary directory with mode `0700` and filename like `/tmp/tmp-nk2J1u`.
+
+```javascript
+var tmp = require('tmp-promise');
+tmp.dir({ template: '/tmp/tmp-XXXXXX' }).then(console.log);
+```
+
+
+### mkstemp like, synchronously
+
+This will behave similarly to the asynchronous version.
+
+```javascript
+var tmp = require('tmp-promise');
+
+var tmpobj = tmp.dirSync({ template: '/tmp/tmp-XXXXXX' });
+console.log("Dir: ", tmpobj.name);
+```
+
+### Asynchronous filename generation
+
+The `tmpName()` function accepts the `prefix`, `postfix`, `dir`, etc. parameters also:
+
+```javascript
+var tmp = require('tmp-promise');
+
+tmp.tmpName({ template: '/tmp/tmp-XXXXXX' }).then(path =>
+    console.log("Created temporary filename: ", path);
+);
+```
+
+### Synchronous filename generation
+
+The `tmpNameSync()` function works similarly to `tmpName()`.
+
+```javascript
+var tmp = require('tmp-promise');
+var tmpname = tmp.tmpNameSync({ template: '/tmp/tmp-XXXXXX' });
+console.log("Created temporary filename: ", tmpname);
+```
+
+
+## Graceful cleanup
+
+One may want to cleanup the temporary files even when an uncaught exception
+occurs. To enforce this, you can call the `setGracefulCleanup()` method:
+
+```javascript
+var tmp = require('tmp');
+
+tmp.setGracefulCleanup();
+```
+
+## Options
+
+All options are optional :)
+
+  * `mode`: the file mode to create with, it fallbacks to `0600` on file creation and `0700` on directory creation
+  * `prefix`: the optional prefix, fallbacks to `tmp-` if not provided
+  * `postfix`: the optional postfix, fallbacks to `.tmp` on file creation
+  * `template`: [`mkstemp`][3] like filename template, no default
+  * `dir`: the optional temporary directory, fallbacks to system default (guesses from environment)
+  * `tries`: how many times should the function try to get a unique filename before giving up, default `3`
+  * `keep`: signals that the temporary file or directory should not be deleted on exit, default is `false`, means delete
+    * Please keep in mind that it is recommended in this case to call the provided `cleanupCallback` function manually.
+  * `unsafeCleanup`: recursively removes the created temporary directory, even when it's not empty. default is `false`
+
+
+
+[1]: http://nodejs.org/
+[2]: https://www.npmjs.com/browse/depended/tmp
+[3]: http://www.kernel.org/doc/man-pages/online/pages/man3/mkstemp.3.html

node_modules/tmp-promise/example-usage.js

@@ -0,0 +1,9 @@
+var tmp = require("./index.js");
+var Promise = require("bluebird"); // just for delay, this works with native promises
+// disposer
+tmp.withFile((path) => {
+	console.log("Created at path", path);
+	return Promise.delay(1000);
+}).then(() => {
+	console.log("File automatically disposed");
+});

node_modules/tmp-promise/index.d.ts

@@ -0,0 +1,27 @@
+import { fileSync, dirSync, tmpNameSync, setGracefulCleanup } from "tmp";
+import { FileOptions, DirOptions, TmpNameOptions } from "tmp";
+
+export interface DirectoryResult {
+  path: string;
+  cleanup: () => Promise<void>;
+}
+
+export interface FileResult extends DirectoryResult {
+  fd: number;
+}
+
+export function file(options?: FileOptions): Promise<FileResult>;
+export function withFile<T>(
+  fn: (result: FileResult) => Promise<T>,
+  options?: FileOptions
+): Promise<T>;
+
+export function dir(options?: DirOptions): Promise<DirectoryResult>;
+export function withDir<T>(
+  fn: (results: DirectoryResult) => Promise<T>,
+  options?: DirOptions
+): Promise<T>;
+
+export function tmpName(options?: TmpNameOptions): Promise<string>;
+
+export { fileSync, dirSync, tmpNameSync, setGracefulCleanup };

node_modules/tmp-promise/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { promisify } = require("util");
+const tmp = require("tmp");
+
+// file
+module.exports.fileSync = tmp.fileSync;
+const fileWithOptions = promisify((options, cb) =>
+  tmp.file(options, (err, path, fd, cleanup) =>
+    err ? cb(err) : cb(undefined, { path, fd, cleanup: promisify(cleanup) })
+  )
+);
+module.exports.file = async (options) => fileWithOptions(options);
+
+module.exports.withFile = async function withFile(fn, options) {
+  const { path, fd, cleanup } = await module.exports.file(options);
+  try {
+    return await fn({ path, fd });
+  } finally {
+    await cleanup();
+  }
+};
+
+
+// directory
+module.exports.dirSync = tmp.dirSync;
+const dirWithOptions = promisify((options, cb) =>
+  tmp.dir(options, (err, path, cleanup) =>
+    err ? cb(err) : cb(undefined, { path, cleanup: promisify(cleanup) })
+  )
+);
+module.exports.dir = async (options) => dirWithOptions(options);
+
+module.exports.withDir = async function withDir(fn, options) {
+  const { path, cleanup } = await module.exports.dir(options);
+  try {
+    return await fn({ path });
+  } finally {
+    await cleanup();
+  }
+};
+
+
+// name generation
+module.exports.tmpNameSync = tmp.tmpNameSync;
+module.exports.tmpName = promisify(tmp.tmpName);
+
+module.exports.tmpdir = tmp.tmpdir;
+
+module.exports.setGracefulCleanup = tmp.setGracefulCleanup;

node_modules/tmp-promise/index.test-d.ts

@@ -0,0 +1,31 @@
+import { file, withFile, dir, withDir, tmpName } from ".";
+
+async function fileExample() {
+  const { path, fd, cleanup } = await file({ discardDescriptor: true });
+  await cleanup();
+
+  await withFile(
+    async ({ path, fd, cleanup }) => {
+      console.log(fd);
+      await cleanup();
+    },
+    { discardDescriptor: true }
+  );
+}
+
+async function dirExample() {
+  const { path, cleanup } = await dir({ unsafeCleanup: true });
+  await cleanup();
+
+  await withDir(
+    async ({ path, cleanup }) => {
+      console.log(path);
+      await cleanup();
+    },
+    { unsafeCleanup: true }
+  );
+}
+
+async function tmpNameExample() {
+  const name = await tmpName({ tries: 3 });
+}

node_modules/tmp-promise/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "tmp-promise",
+  "version": "3.0.3",
+  "description": "The tmp package with promises support and disposers.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "mocha": "mocha",
+    "check-types": "tsd",
+    "test": "npm run mocha && npm run check-types",
+    "publish": "node publish"
+  },
+  "keywords": [
+    "tmp",
+    "promise",
+    "tempfile",
+    "mkdtemp",
+    "mktemp"
+  ],
+  "author": "Benjamin Gruenbaum and Collaborators.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/benjamingr/tmp-promise.git"
+  },
+  "dependencies": {
+    "tmp": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/tmp": "^0.2.0",
+    "mocha": "7.1.2",
+    "tsd": "0.11.0"
+  }
+}

node_modules/tmp-promise/publish.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const { version } = require('./package');
+
+execSync('npm run test');
+execSync(`git tag v${version}`);
+execSync('npm publish');

node_modules/tmp-promise/test.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const fs = require('fs')
+const assert = require('assert')
+const { extname } = require('path')
+
+const tmp = require('.')
+
+async function checkFileResult(result) {
+  assert.deepEqual(Object.keys(result).sort(), ['cleanup', 'fd', 'path'])
+
+  const { path, fd, cleanup } = result
+  assert.ok(typeof path === 'string')
+  assert.ok(typeof fd === 'number')
+  assert.ok(typeof cleanup === 'function')
+
+  // Check that the path is a fille.
+  assert.ok(fs.statSync(path).isFile())
+
+  // Check that the fd is correct and points to the file.
+  const message = 'hello there!'
+  fs.writeSync(fd, message)
+  fs.fdatasyncSync(fd)
+  assert.equal(fs.readFileSync(path), message)
+
+  // Check that the cleanup works.
+  await cleanup()
+  assert.throws(() => fs.statSync(path))
+}
+
+describe('file()', function()
+{
+  context('when called without options', function()
+  {
+    it('creates the file, returns the expected result, and the cleanup function works', async function()
+    {
+      const result = await tmp.file()
+      await checkFileResult(result)
+    })
+  })
+
+  context('when called with options', function()
+  {
+    it('creates the file, returns the expected result, and the cleanup function works', async function()
+    {
+      const prefix = 'myTmpDir_'
+      const result = await tmp.file({ prefix })
+      await checkFileResult(result)
+      assert.ok(result.path.includes(prefix))
+    })
+  })
+
+  it('propagates errors', async function() {
+    try {
+      await tmp.file({ dir: 'nonexistent-path' });
+      throw Error('Expected to throw');
+    } catch (e) {
+      assert.ok(e.message.startsWith('ENOENT: no such file or directory'));
+    }
+  });
+})
+
+async function checkDirResult(result) {
+  assert.deepEqual(Object.keys(result).sort(), ['cleanup', 'path'])
+
+  const { path, cleanup } = result
+  assert.ok(typeof path === 'string')
+  assert.ok(typeof cleanup === 'function')
+
+  assert.ok(fs.statSync(path).isDirectory())
+
+  await cleanup()
+  assert.throws(() => fs.statSync(path))
+}
+
+describe('dir()', function()
+{
+  context('when called without options', function()
+  {
+    it('creates the directory, returns the expected result, and the cleanup function works', async function()
+    {
+      const result = await tmp.dir()
+      await checkDirResult(result)
+    })
+  })
+
+  context('when called with options', function()
+  {
+    it('creates the directory, returns the expected result, and the cleanup function works', async function()
+    {
+      const prefix = 'myTmpDir_'
+      const result = await tmp.dir({ prefix })
+      await checkDirResult(result)
+      assert.ok(result.path.includes(prefix))
+    })
+  })
+
+  it('propagates errors', async function() {
+    try {
+      await tmp.dir({ dir: 'nonexistent-path' });
+      throw Error('Expected to throw');
+    } catch (e) {
+      assert.ok(e.message.startsWith('ENOENT: no such file or directory'));
+    }
+  });
+})
+
+describe('withFile()', function()
+{
+  it("file doesn't exist after going out of scope", function()
+  {
+    var filepath
+
+    return tmp.withFile(function(o)
+    {
+      filepath = o.path
+
+      fs.accessSync(filepath)
+      assert.strictEqual(extname(filepath), '.txt')
+    }, {discardDescriptor: true, postfix: '.txt'})
+    .then(function()
+    {
+      assert.throws(function()
+      {
+        fs.accessSync(filepath)
+      }, filepath + ' still exists')
+    })
+  })
+})
+
+
+describe('withDir()', function()
+{
+  it("dir doesn't exist after going out of scope", function()
+  {
+    var filepath
+
+    return tmp.withDir(function(o)
+    {
+      filepath = o.path
+
+      fs.accessSync(filepath)
+      assert.strictEqual(extname(filepath), '.dir')
+    }, {postfix: '.dir'})
+    .then(function()
+    {
+      assert.throws(function()
+      {
+        fs.accessSync(filepath)
+      }, filepath + ' still exists')
+    })
+  })
+})