zmdms-webui 1.9.3 → 1.9.5

package/dist/es/node_modules/tmp/lib/tmp.js

@@ -0,0 +1,854 @@
+import { __module as tmp } from '../../../_virtual/tmp.js';
+import require$$0 from 'fs';
+import require$$1 from 'os';
+import require$$1$1 from 'path';
+import require$$0$1 from 'crypto';
+
+/*!
+ * Tmp
+ *
+ * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
+ *
+ * MIT Licensed
+ */
+
+(function (module) {
+	/*
+	 * Module dependencies.
+	 */
+	const fs = require$$0;
+	const os = require$$1;
+	const path = require$$1$1;
+	const crypto = require$$0$1;
+	const _c = { fs: fs.constants, os: os.constants };
+
+	/*
+	 * The working inner variables.
+	 */
+	const // the random characters to choose from
+	  RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+	  TEMPLATE_PATTERN = /XXXXXX/,
+	  DEFAULT_TRIES = 3,
+	  CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR),
+	  // constants are off on the windows platform and will not match the actual errno codes
+	  IS_WIN32 = os.platform() === 'win32',
+	  EBADF = _c.EBADF || _c.os.errno.EBADF,
+	  ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
+	  DIR_MODE = 0o700 /* 448 */,
+	  FILE_MODE = 0o600 /* 384 */,
+	  EXIT = 'exit',
+	  // this will hold the objects need to be removed on exit
+	  _removeObjects = [],
+	  // API change in fs.rmdirSync leads to error when passing in a second parameter, e.g. the callback
+	  FN_RMDIR_SYNC = fs.rmdirSync.bind(fs);
+
+	let _gracefulCleanup = false;
+
+	/**
+	 * Recursively remove a directory and its contents.
+	 *
+	 * @param {string} dirPath path of directory to remove
+	 * @param {Function} callback
+	 * @private
+	 */
+	function rimraf(dirPath, callback) {
+	  return fs.rm(dirPath, { recursive: true }, callback);
+	}
+
+	/**
+	 * Recursively remove a directory and its contents, synchronously.
+	 *
+	 * @param {string} dirPath path of directory to remove
+	 * @private
+	 */
+	function FN_RIMRAF_SYNC(dirPath) {
+	  return fs.rmSync(dirPath, { recursive: true });
+	}
+
+	/**
+	 * Gets a temporary file name.
+	 *
+	 * @param {(Options|tmpNameCallback)} options options or callback
+	 * @param {?tmpNameCallback} callback the callback function
+	 */
+	function tmpName(options, callback) {
+	  const args = _parseArguments(options, callback),
+	    opts = args[0],
+	    cb = args[1];
+
+	  _assertAndSanitizeOptions(opts, function (err, sanitizedOptions) {
+	    if (err) return cb(err);
+
+	    let tries = sanitizedOptions.tries;
+	    (function _getUniqueName() {
+	      try {
+	        const name = _generateTmpName(sanitizedOptions);
+
+	        // check whether the path exists then retry if needed
+	        fs.stat(name, function (err) {
+	          /* istanbul ignore else */
+	          if (!err) {
+	            /* istanbul ignore else */
+	            if (tries-- > 0) return _getUniqueName();
+
+	            return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
+	          }
+
+	          cb(null, name);
+	        });
+	      } catch (err) {
+	        cb(err);
+	      }
+	    })();
+	  });
+	}
+
+	/**
+	 * Synchronous version of tmpName.
+	 *
+	 * @param {Object} options
+	 * @returns {string} the generated random name
+	 * @throws {Error} if the options are invalid or could not generate a filename
+	 */
+	function tmpNameSync(options) {
+	  const args = _parseArguments(options),
+	    opts = args[0];
+
+	  const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);
+
+	  let tries = sanitizedOptions.tries;
+	  do {
+	    const name = _generateTmpName(sanitizedOptions);
+	    try {
+	      fs.statSync(name);
+	    } catch (e) {
+	      return name;
+	    }
+	  } while (tries-- > 0);
+
+	  throw new Error('Could not get a unique tmp filename, max tries reached');
+	}
+
+	/**
+	 * Creates and opens a temporary file.
+	 *
+	 * @param {(Options|null|undefined|fileCallback)} options the config options or the callback function or null or undefined
+	 * @param {?fileCallback} callback
+	 */
+	function file(options, callback) {
+	  const args = _parseArguments(options, callback),
+	    opts = args[0],
+	    cb = args[1];
+
+	  // gets a temporary filename
+	  tmpName(opts, function _tmpNameCreated(err, name) {
+	    /* istanbul ignore else */
+	    if (err) return cb(err);
+
+	    // create and open the file
+	    fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
+	      /* istanbu ignore else */
+	      if (err) return cb(err);
+
+	      if (opts.discardDescriptor) {
+	        return fs.close(fd, function _discardCallback(possibleErr) {
+	          // the chance of getting an error on close here is rather low and might occur in the most edgiest cases only
+	          return cb(possibleErr, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts, false));
+	        });
+	      } else {
+	        // detachDescriptor passes the descriptor whereas discardDescriptor closes it, either way, we no longer care
+	        // about the descriptor
+	        const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+	        cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
+	      }
+	    });
+	  });
+	}
+
+	/**
+	 * Synchronous version of file.
+	 *
+	 * @param {Options} options
+	 * @returns {FileSyncObject} object consists of name, fd and removeCallback
+	 * @throws {Error} if cannot create a file
+	 */
+	function fileSync(options) {
+	  const args = _parseArguments(options),
+	    opts = args[0];
+
+	  const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+	  const name = tmpNameSync(opts);
+	  let fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+	  /* istanbul ignore else */
+	  if (opts.discardDescriptor) {
+	    fs.closeSync(fd);
+	    fd = undefined;
+	  }
+
+	  return {
+	    name: name,
+	    fd: fd,
+	    removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
+	  };
+	}
+
+	/**
+	 * Creates a temporary directory.
+	 *
+	 * @param {(Options|dirCallback)} options the options or the callback function
+	 * @param {?dirCallback} callback
+	 */
+	function dir(options, callback) {
+	  const args = _parseArguments(options, callback),
+	    opts = args[0],
+	    cb = args[1];
+
+	  // gets a temporary filename
+	  tmpName(opts, function _tmpNameCreated(err, name) {
+	    /* istanbul ignore else */
+	    if (err) return cb(err);
+
+	    // create the directory
+	    fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
+	      /* istanbul ignore else */
+	      if (err) return cb(err);
+
+	      cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
+	    });
+	  });
+	}
+
+	/**
+	 * Synchronous version of dir.
+	 *
+	 * @param {Options} options
+	 * @returns {DirSyncObject} object consists of name and removeCallback
+	 * @throws {Error} if it cannot create a directory
+	 */
+	function dirSync(options) {
+	  const args = _parseArguments(options),
+	    opts = args[0];
+
+	  const name = tmpNameSync(opts);
+	  fs.mkdirSync(name, opts.mode || DIR_MODE);
+
+	  return {
+	    name: name,
+	    removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
+	  };
+	}
+
+	/**
+	 * Removes files asynchronously.
+	 *
+	 * @param {Object} fdPath
+	 * @param {Function} next
+	 * @private
+	 */
+	function _removeFileAsync(fdPath, next) {
+	  const _handler = function (err) {
+	    if (err && !_isENOENT(err)) {
+	      // reraise any unanticipated error
+	      return next(err);
+	    }
+	    next();
+	  };
+
+	  if (0 <= fdPath[0])
+	    fs.close(fdPath[0], function () {
+	      fs.unlink(fdPath[1], _handler);
+	    });
+	  else fs.unlink(fdPath[1], _handler);
+	}
+
+	/**
+	 * Removes files synchronously.
+	 *
+	 * @param {Object} fdPath
+	 * @private
+	 */
+	function _removeFileSync(fdPath) {
+	  let rethrownException = null;
+	  try {
+	    if (0 <= fdPath[0]) fs.closeSync(fdPath[0]);
+	  } catch (e) {
+	    // reraise any unanticipated error
+	    if (!_isEBADF(e) && !_isENOENT(e)) throw e;
+	  } finally {
+	    try {
+	      fs.unlinkSync(fdPath[1]);
+	    } catch (e) {
+	      // reraise any unanticipated error
+	      if (!_isENOENT(e)) rethrownException = e;
+	    }
+	  }
+	  if (rethrownException !== null) {
+	    throw rethrownException;
+	  }
+	}
+
+	/**
+	 * Prepares the callback for removal of the temporary file.
+	 *
+	 * Returns either a sync callback or a async callback depending on whether
+	 * fileSync or file was called, which is expressed by the sync parameter.
+	 *
+	 * @param {string} name the path of the file
+	 * @param {number} fd file descriptor
+	 * @param {Object} opts
+	 * @param {boolean} sync
+	 * @returns {fileCallback | fileCallbackSync}
+	 * @private
+	 */
+	function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
+	  const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
+	  const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
+
+	  if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
+
+	  return sync ? removeCallbackSync : removeCallback;
+	}
+
+	/**
+	 * Prepares the callback for removal of the temporary directory.
+	 *
+	 * Returns either a sync callback or a async callback depending on whether
+	 * tmpFileSync or tmpFile was called, which is expressed by the sync parameter.
+	 *
+	 * @param {string} name
+	 * @param {Object} opts
+	 * @param {boolean} sync
+	 * @returns {Function} the callback
+	 * @private
+	 */
+	function _prepareTmpDirRemoveCallback(name, opts, sync) {
+	  const removeFunction = opts.unsafeCleanup ? rimraf : fs.rmdir.bind(fs);
+	  const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
+	  const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
+	  const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
+	  if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
+
+	  return sync ? removeCallbackSync : removeCallback;
+	}
+
+	/**
+	 * Creates a guarded function wrapping the removeFunction call.
+	 *
+	 * The cleanup callback is save to be called multiple times.
+	 * Subsequent invocations will be ignored.
+	 *
+	 * @param {Function} removeFunction
+	 * @param {string} fileOrDirName
+	 * @param {boolean} sync
+	 * @param {cleanupCallbackSync?} cleanupCallbackSync
+	 * @returns {cleanupCallback | cleanupCallbackSync}
+	 * @private
+	 */
+	function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
+	  let called = false;
+
+	  // if sync is true, the next parameter will be ignored
+	  return function _cleanupCallback(next) {
+	    /* istanbul ignore else */
+	    if (!called) {
+	      // remove cleanupCallback from cache
+	      const toRemove = cleanupCallbackSync || _cleanupCallback;
+	      const index = _removeObjects.indexOf(toRemove);
+	      /* istanbul ignore else */
+	      if (index >= 0) _removeObjects.splice(index, 1);
+
+	      called = true;
+	      if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
+	        return removeFunction(fileOrDirName);
+	      } else {
+	        return removeFunction(fileOrDirName, next || function () {});
+	      }
+	    }
+	  };
+	}
+
+	/**
+	 * The garbage collector.
+	 *
+	 * @private
+	 */
+	function _garbageCollector() {
+	  /* istanbul ignore else */
+	  if (!_gracefulCleanup) return;
+
+	  // the function being called removes itself from _removeObjects,
+	  // loop until _removeObjects is empty
+	  while (_removeObjects.length) {
+	    try {
+	      _removeObjects[0]();
+	    } catch (e) {
+	      // already removed?
+	    }
+	  }
+	}
+
+	/**
+	 * Random name generator based on crypto.
+	 * Adapted from http://blog.tompawlak.org/how-to-generate-random-values-nodejs-javascript
+	 *
+	 * @param {number} howMany
+	 * @returns {string} the generated random name
+	 * @private
+	 */
+	function _randomChars(howMany) {
+	  let value = [],
+	    rnd = null;
+
+	  // make sure that we do not fail because we ran out of entropy
+	  try {
+	    rnd = crypto.randomBytes(howMany);
+	  } catch (e) {
+	    rnd = crypto.pseudoRandomBytes(howMany);
+	  }
+
+	  for (let i = 0; i < howMany; i++) {
+	    value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
+	  }
+
+	  return value.join('');
+	}
+
+	/**
+	 * Checks whether the `obj` parameter is defined or not.
+	 *
+	 * @param {Object} obj
+	 * @returns {boolean} true if the object is undefined
+	 * @private
+	 */
+	function _isUndefined(obj) {
+	  return typeof obj === 'undefined';
+	}
+
+	/**
+	 * Parses the function arguments.
+	 *
+	 * This function helps to have optional arguments.
+	 *
+	 * @param {(Options|null|undefined|Function)} options
+	 * @param {?Function} callback
+	 * @returns {Array} parsed arguments
+	 * @private
+	 */
+	function _parseArguments(options, callback) {
+	  /* istanbul ignore else */
+	  if (typeof options === 'function') {
+	    return [{}, options];
+	  }
+
+	  /* istanbul ignore else */
+	  if (_isUndefined(options)) {
+	    return [{}, callback];
+	  }
+
+	  // copy options so we do not leak the changes we make internally
+	  const actualOptions = {};
+	  for (const key of Object.getOwnPropertyNames(options)) {
+	    actualOptions[key] = options[key];
+	  }
+
+	  return [actualOptions, callback];
+	}
+
+	/**
+	 * Resolve the specified path name in respect to tmpDir.
+	 *
+	 * The specified name might include relative path components, e.g. ../
+	 * so we need to resolve in order to be sure that is is located inside tmpDir
+	 *
+	 * @private
+	 */
+	function _resolvePath(name, tmpDir, cb) {
+	  const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);
+
+	  fs.stat(pathToResolve, function (err) {
+	    if (err) {
+	      fs.realpath(path.dirname(pathToResolve), function (err, parentDir) {
+	        if (err) return cb(err);
+
+	        cb(null, path.join(parentDir, path.basename(pathToResolve)));
+	      });
+	    } else {
+	      fs.realpath(pathToResolve, cb);
+	    }
+	  });
+	}
+
+	/**
+	 * Resolve the specified path name in respect to tmpDir.
+	 *
+	 * The specified name might include relative path components, e.g. ../
+	 * so we need to resolve in order to be sure that is is located inside tmpDir
+	 *
+	 * @private
+	 */
+	function _resolvePathSync(name, tmpDir) {
+	  const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);
+
+	  try {
+	    fs.statSync(pathToResolve);
+	    return fs.realpathSync(pathToResolve);
+	  } catch (_err) {
+	    const parentDir = fs.realpathSync(path.dirname(pathToResolve));
+
+	    return path.join(parentDir, path.basename(pathToResolve));
+	  }
+	}
+
+	/**
+	 * Generates a new temporary name.
+	 *
+	 * @param {Object} opts
+	 * @returns {string} the new random name according to opts
+	 * @private
+	 */
+	function _generateTmpName(opts) {
+	  const tmpDir = opts.tmpdir;
+
+	  /* istanbul ignore else */
+	  if (!_isUndefined(opts.name)) {
+	    return path.join(tmpDir, opts.dir, opts.name);
+	  }
+
+	  /* istanbul ignore else */
+	  if (!_isUndefined(opts.template)) {
+	    return path.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+	  }
+
+	  // prefix and postfix
+	  const name = [
+	    opts.prefix ? opts.prefix : 'tmp',
+	    '-',
+	    process.pid,
+	    '-',
+	    _randomChars(12),
+	    opts.postfix ? '-' + opts.postfix : ''
+	  ].join('');
+
+	  return path.join(tmpDir, opts.dir, name);
+	}
+
+	/**
+	 * Asserts and sanitizes the basic options.
+	 *
+	 * @private
+	 */
+	function _assertOptionsBase(options) {
+	  if (!_isUndefined(options.name)) {
+	    const name = options.name;
+
+	    // assert that name is not absolute and does not contain a path
+	    if (path.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
+
+	    // must not fail on valid .<name> or ..<name> or similar such constructs
+	    const basename = path.basename(name);
+	    if (basename === '..' || basename === '.' || basename !== name)
+	      throw new Error(`name option must not contain a path, found "${name}".`);
+	  }
+
+	  /* istanbul ignore else */
+	  if (!_isUndefined(options.template) && !options.template.match(TEMPLATE_PATTERN)) {
+	    throw new Error(`Invalid template, found "${options.template}".`);
+	  }
+
+	  /* istanbul ignore else */
+	  if ((!_isUndefined(options.tries) && isNaN(options.tries)) || options.tries < 0) {
+	    throw new Error(`Invalid tries, found "${options.tries}".`);
+	  }
+
+	  // if a name was specified we will try once
+	  options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
+	  options.keep = !!options.keep;
+	  options.detachDescriptor = !!options.detachDescriptor;
+	  options.discardDescriptor = !!options.discardDescriptor;
+	  options.unsafeCleanup = !!options.unsafeCleanup;
+
+	  // for completeness' sake only, also keep (multiple) blanks if the user, purportedly sane, requests us to
+	  options.prefix = _isUndefined(options.prefix) ? '' : options.prefix;
+	  options.postfix = _isUndefined(options.postfix) ? '' : options.postfix;
+	}
+
+	/**
+	 * Gets the relative directory to tmpDir.
+	 *
+	 * @private
+	 */
+	function _getRelativePath(option, name, tmpDir, cb) {
+	  if (_isUndefined(name)) return cb(null);
+
+	  _resolvePath(name, tmpDir, function (err, resolvedPath) {
+	    if (err) return cb(err);
+
+	    const relativePath = path.relative(tmpDir, resolvedPath);
+
+	    if (!resolvedPath.startsWith(tmpDir)) {
+	      return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
+	    }
+
+	    cb(null, relativePath);
+	  });
+	}
+
+	/**
+	 * Gets the relative path to tmpDir.
+	 *
+	 * @private
+	 */
+	function _getRelativePathSync(option, name, tmpDir) {
+	  if (_isUndefined(name)) return;
+
+	  const resolvedPath = _resolvePathSync(name, tmpDir);
+	  const relativePath = path.relative(tmpDir, resolvedPath);
+
+	  if (!resolvedPath.startsWith(tmpDir)) {
+	    throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
+	  }
+
+	  return relativePath;
+	}
+
+	/**
+	 * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
+	 * options.
+	 *
+	 * @private
+	 */
+	function _assertAndSanitizeOptions(options, cb) {
+	  _getTmpDir(options, function (err, tmpDir) {
+	    if (err) return cb(err);
+
+	    options.tmpdir = tmpDir;
+
+	    try {
+	      _assertOptionsBase(options, tmpDir);
+	    } catch (err) {
+	      return cb(err);
+	    }
+
+	    // sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
+	    _getRelativePath('dir', options.dir, tmpDir, function (err, dir) {
+	      if (err) return cb(err);
+
+	      options.dir = _isUndefined(dir) ? '' : dir;
+
+	      // sanitize further if template is relative to options.dir
+	      _getRelativePath('template', options.template, tmpDir, function (err, template) {
+	        if (err) return cb(err);
+
+	        options.template = template;
+
+	        cb(null, options);
+	      });
+	    });
+	  });
+	}
+
+	/**
+	 * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
+	 * options.
+	 *
+	 * @private
+	 */
+	function _assertAndSanitizeOptionsSync(options) {
+	  const tmpDir = (options.tmpdir = _getTmpDirSync(options));
+
+	  _assertOptionsBase(options);
+
+	  const dir = _getRelativePathSync('dir', options.dir, tmpDir);
+	  options.dir = _isUndefined(dir) ? '' : dir;
+
+	  options.template = _getRelativePathSync('template', options.template, tmpDir);
+
+	  return options;
+	}
+
+	/**
+	 * Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
+	 *
+	 * @private
+	 */
+	function _isEBADF(error) {
+	  return _isExpectedError(error, -EBADF, 'EBADF');
+	}
+
+	/**
+	 * Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
+	 *
+	 * @private
+	 */
+	function _isENOENT(error) {
+	  return _isExpectedError(error, -ENOENT, 'ENOENT');
+	}
+
+	/**
+	 * Helper to determine whether the expected error code matches the actual code and errno,
+	 * which will differ between the supported node versions.
+	 *
+	 * - Node >= 7.0:
+	 *   error.code {string}
+	 *   error.errno {number} any numerical value will be negated
+	 *
+	 * CAVEAT
+	 *
+	 * On windows, the errno for EBADF is -4083 but os.constants.errno.EBADF is different and we must assume that ENOENT
+	 * is no different here.
+	 *
+	 * @param {SystemError} error
+	 * @param {number} errno
+	 * @param {string} code
+	 * @private
+	 */
+	function _isExpectedError(error, errno, code) {
+	  return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
+	}
+
+	/**
+	 * Sets the graceful cleanup.
+	 *
+	 * If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the
+	 * temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary
+	 * object removals.
+	 */
+	function setGracefulCleanup() {
+	  _gracefulCleanup = true;
+	}
+
+	/**
+	 * Returns the currently configured tmp dir from os.tmpdir().
+	 *
+	 * @private
+	 */
+	function _getTmpDir(options, cb) {
+	  return fs.realpath((options && options.tmpdir) || os.tmpdir(), cb);
+	}
+
+	/**
+	 * Returns the currently configured tmp dir from os.tmpdir().
+	 *
+	 * @private
+	 */
+	function _getTmpDirSync(options) {
+	  return fs.realpathSync((options && options.tmpdir) || os.tmpdir());
+	}
+
+	// Install process exit listener
+	process.addListener(EXIT, _garbageCollector);
+
+	/**
+	 * Configuration options.
+	 *
+	 * @typedef {Object} Options
+	 * @property {?boolean} keep the temporary object (file or dir) will not be garbage collected
+	 * @property {?number} tries the number of tries before give up the name generation
+	 * @property (?int) mode the access mode, defaults are 0o700 for directories and 0o600 for files
+	 * @property {?string} template the "mkstemp" like filename template
+	 * @property {?string} name fixed name relative to tmpdir or the specified dir option
+	 * @property {?string} dir tmp directory relative to the root tmp directory in use
+	 * @property {?string} prefix prefix for the generated name
+	 * @property {?string} postfix postfix for the generated name
+	 * @property {?string} tmpdir the root tmp directory which overrides the os tmpdir
+	 * @property {?boolean} unsafeCleanup recursively removes the created temporary directory, even when it's not empty
+	 * @property {?boolean} detachDescriptor detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collection
+	 * @property {?boolean} discardDescriptor discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection
+	 */
+
+	/**
+	 * @typedef {Object} FileSyncObject
+	 * @property {string} name the name of the file
+	 * @property {string} fd the file descriptor or -1 if the fd has been discarded
+	 * @property {fileCallback} removeCallback the callback function to remove the file
+	 */
+
+	/**
+	 * @typedef {Object} DirSyncObject
+	 * @property {string} name the name of the directory
+	 * @property {fileCallback} removeCallback the callback function to remove the directory
+	 */
+
+	/**
+	 * @callback tmpNameCallback
+	 * @param {?Error} err the error object if anything goes wrong
+	 * @param {string} name the temporary file name
+	 */
+
+	/**
+	 * @callback fileCallback
+	 * @param {?Error} err the error object if anything goes wrong
+	 * @param {string} name the temporary file name
+	 * @param {number} fd the file descriptor or -1 if the fd had been discarded
+	 * @param {cleanupCallback} fn the cleanup callback function
+	 */
+
+	/**
+	 * @callback fileCallbackSync
+	 * @param {?Error} err the error object if anything goes wrong
+	 * @param {string} name the temporary file name
+	 * @param {number} fd the file descriptor or -1 if the fd had been discarded
+	 * @param {cleanupCallbackSync} fn the cleanup callback function
+	 */
+
+	/**
+	 * @callback dirCallback
+	 * @param {?Error} err the error object if anything goes wrong
+	 * @param {string} name the temporary file name
+	 * @param {cleanupCallback} fn the cleanup callback function
+	 */
+
+	/**
+	 * @callback dirCallbackSync
+	 * @param {?Error} err the error object if anything goes wrong
+	 * @param {string} name the temporary file name
+	 * @param {cleanupCallbackSync} fn the cleanup callback function
+	 */
+
+	/**
+	 * Removes the temporary created file or directory.
+	 *
+	 * @callback cleanupCallback
+	 * @param {simpleCallback} [next] function to call whenever the tmp object needs to be removed
+	 */
+
+	/**
+	 * Removes the temporary created file or directory.
+	 *
+	 * @callback cleanupCallbackSync
+	 */
+
+	/**
+	 * Callback function for function composition.
+	 * @see {@link https://github.com/raszi/node-tmp/issues/57|raszi/node-tmp#57}
+	 *
+	 * @callback simpleCallback
+	 */
+
+	// exporting all the needed methods
+
+	// evaluate _getTmpDir() lazily, mainly for simplifying testing but it also will
+	// allow users to reconfigure the temporary directory
+	Object.defineProperty(module.exports, 'tmpdir', {
+	  enumerable: true,
+	  configurable: false,
+	  get: function () {
+	    return _getTmpDirSync();
+	  }
+	});
+
+	module.exports.dir = dir;
+	module.exports.dirSync = dirSync;
+
+	module.exports.file = file;
+	module.exports.fileSync = fileSync;
+
+	module.exports.tmpName = tmpName;
+	module.exports.tmpNameSync = tmpNameSync;
+
+	module.exports.setGracefulCleanup = setGracefulCleanup; 
+} (tmp));
+
+var tmpExports = tmp.exports;
+
+export { tmpExports as t };