How to use the uglify-js.minify function in uglify-js

logger.info('[settings] Checking for new settings.');

		// 1. retrieve added properties
		let oldTree = {};
		let newTree = {};
		eval(settingsCurr.replace(/module\.exports\s*=\s*\{/, 'oldTree = {')); // jshint ignore:line
		eval(settingsDist.replace(/module\.exports\s*=\s*\{/, 'newTree = {')); // jshint ignore:line
		let newProps = diff(oldTree, newTree);
		if (newProps.length === 0) {
			logger.info('[settings] No new settings found.');
			return callback(result);
		}
		logger.info('[settings] Found new settings: [' + newProps.join(', ') + ']');

		// 2. retrieve code blocks of added properties
		let nodesNew = analyze(uglify.minify(settingsDist, {
			compress: false,
			mangle: false,
			output: {
				ast: true,
				code: false
			}
		}).ast);

		// 3. inject code blocks into settings.js
		let settingsPatched = _.clone(settingsCurr);
		let settingsNew = _.pick(nodesNew, newProps);
		let settingsNewKeys = _.keys(settingsNew);
		let ast;
		for (let i = 0; i < settingsNewKeys.length; i++) {
			let path = settingsNewKeys[i]; // path in settings to be added
			let node = settingsNew[path];  // ast node corresponding to the setting to be added

uglify: function minifyUglifyJS(src, file) {
        try {
            return UglifyJS.minify(src, {
                fromString: true
            }).code;
        } catch (e) {
            if (e.line != null) {
                console.error(`Failed to minify ${file}`);
                console.error(` Location: ${file}:${e.line}:${e.col}`);
                console.error(` Message: ${e.message}`);
                process.exit(1);
            }
            throw e;
        }
    },
    both: function(src, file) {

srcDelta = getSizeDelta(newSrc, oldSrc, true);

    console.log('\tUncompressed: ' + bytesToKB(newSrc.length) + srcDelta);

    if (newSrc !== oldSrc) {
        fs.writeFileSync(srcPath, newSrc);
        fs.writeFileSync(mapPath, bundle.srcmap);
        console.log('\tSaved to ' + srcPath);
    }

    var path = pathPart + '.js',
        oldCompressed = loadSilently(path),
        newCompressed;

    try {
        newCompressed = copy + UglifyJS.minify(newSrc, {
                warnings: true,
                fromString: true
            }).code;
    } catch(err) {
        console.error('UglifyJS failed to minify the files');
        console.error(err);
        callback(err);
    }

    var delta = getSizeDelta(newCompressed, oldCompressed);

    console.log('\tCompressed: ' + bytesToKB(newCompressed.length) + delta);

    var newGzipped,
        gzippedDelta = '';

]
    }

    if (config.env) {
      rollupConfig.plugins.push(replace({ 'process.env.NODE_ENV': JSON.stringify(config.env) }))
    }

    const bundle = await rollup.rollup(rollupConfig)
    const dest = path.join(dist, `vue-modal-dialogs${config.suffix ? `.${config.suffix}` : ''}.js`)
    let result = await bundle.generate({
      format: config.type,
      name: 'VueModalDialogs'
    })

    if (config.suffix === 'min') {
      result = uglify.minify(result.code)
    }

    console.log(path.parse(dest).base, size(result.code))
    await write(dest, result.code)
  }
}

.on('finish', function() {
    var result = UglifyJS.minify(standalone);
    fs.writeFileSync(minified, result.code);

    console.log('Built version %s to %s', pkg.version, standalone);

    [standalone, minified].map(function(file) {
      var stat = fs.statSync(file);
      console.log("  * %s: %dkb", file, Math.round((stat.size/102.4))/10);
    });
  });

b.bundle(function (err, src) {
      if (err) return reject(err);
      console.log('Compressing', f);
      src = src.toString();
      fs.writeFileSync('dist/' + f, src);
      fs.writeFileSync('docs/js/' + f, src);
      var result = UglifyJS.minify(src, { fromString: true });
      console.log('Writing', f);
      fs.writeFileSync('dist/' + f.replace('.js','.min.js'), result.code);
      resolve();
    });
  });

transform: ( content ) => {
				return UglifyJS.minify( content.toString() ).code;
			},
		};

function minify(code) {
  return UglifyJS.minify(code, {
    mangle: true,
    compress: {
      join_vars: true,
    },
  }).code;
}

function minify(code) {
  var uglify = require('uglify-js');
  var minified = uglify.minify(code, {fromString: true});
  return minified.code;
}

return serviceWorkerCreated.then(function() {
        var dir = process.cwd();
        process.chdir("dist");
        delete process.env.NODE_PATH;
        var minified = UglifyJS.minify("main.js", {
            outSourceMap: "main.js.map"
        });
        process.chdir(dir);
        var codeWritten = fs.writeFileAsync("dist/main.min.js", minified.code, "utf8");
        minified.map = minified.map.replace('"file":"main.js.map"', '"file":"main.min.js"');
        var mapWritten = fs.writeFileAsync("dist/main.js.map", minified.map, "utf8");
        return [codeWritten, mapWritten];
    });
});