| #! /usr/bin/env node |
| // -*- js -*- |
| |
| "use strict"; |
| |
| var UglifyJS = require("../tools/node"); |
| var sys = require("util"); |
| var yargs = require("yargs"); |
| var fs = require("fs"); |
| var path = require("path"); |
| var acorn; |
| var screw_ie8 = true; |
| var ARGS = yargs |
| .usage("$0 input1.js [input2.js ...] [options]\n\ |
| Use a single dash to read input from the standard input.\ |
| \n\n\ |
| NOTE: by default there is no mangling/compression.\n\ |
| Without [options] it will simply parse input files and dump the AST\n\ |
| with whitespace and comments discarded. To achieve compression and\n\ |
| mangling you need to use `-c` and `-m`.\ |
| ") |
| .describe("source-map", "Specify an output file where to generate source map.") |
| .describe("source-map-root", "The path to the original source to be included in the source map.") |
| .describe("source-map-url", "The path to the source map to be added in //# sourceMappingURL. Defaults to the value passed with --source-map.") |
| .describe("source-map-inline", "Write base64-encoded source map to the end of js output. Disabled by default") |
| .describe("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.") |
| .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.") |
| .describe("screw-ie8", "Do not support Internet Explorer 6/7/8. This flag is enabled by default.") |
| .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript.") |
| .describe("expr", "Parse a single expression, rather than a program (for parsing JSON)") |
| .describe("p", "Skip prefix for original filenames that appear in source maps. \ |
| For example -p 3 will drop 3 directories from file names and ensure they are relative paths. \ |
| You can also specify -p relative, which will make UglifyJS figure out itself the relative paths between original sources, \ |
| the source map and the output file.") |
| .describe("o", "Output file (default STDOUT).") |
| .describe("b", "Beautify output/specify output options.") |
| .describe("m", "Mangle names/pass mangler options.") |
| .describe("r", "Reserved names to exclude from mangling.") |
| .describe("c", "Enable compressor/pass compressor options. \ |
| Pass options like -c hoist_vars=false,if_return=false. \ |
| Use -c with no argument to use the default compression options.") |
| .describe("d", "Global definitions") |
| .describe("e", "Embed everything in a big function, with a configurable parameter/argument list.") |
| |
| .describe("comments", "Preserve copyright comments in the output. \ |
| By default this works like Google Closure, keeping JSDoc-style comments that contain \"@license\" or \"@preserve\". \ |
| You can optionally pass one of the following arguments to this flag:\n\ |
| - \"all\" to keep all comments\n\ |
| - a valid JS RegExp like `/foo/`or `/^!/` to keep only matching comments.\n\ |
| \ |
| Note that currently not *all* comments can be kept when compression is on, \ |
| because of dead code removal or cascading statements into sequences.") |
| |
| .describe("preamble", "Preamble to prepend to the output. You can use this to insert a \ |
| comment, for example for licensing information. This will not be \ |
| parsed, but the source map will adjust for its presence.") |
| |
| .describe("stats", "Display operations run time on STDERR.") |
| .describe("acorn", "Use Acorn for parsing.") |
| .describe("spidermonkey", "Assume input files are SpiderMonkey AST format (as JSON).") |
| .describe("self", "Build itself (UglifyJS2) as a library (implies --wrap=UglifyJS --export-all)") |
| .describe("wrap", "Embed everything in a big function, making the “exports” and “global” variables available. \ |
| You need to pass an argument to this option to specify the name that your module will take when included in, say, a browser.") |
| .describe("export-all", "Only used when --wrap, this tells UglifyJS to add code to automatically export all globals.") |
| .describe("lint", "Display some scope warnings") |
| .describe("v", "Verbose") |
| .describe("V", "Print version number and exit.") |
| .describe("noerr", "Don't throw an error for unknown options in -c, -b or -m.") |
| .describe("bare-returns", "Allow return outside of functions. Useful when minifying CommonJS modules.") |
| .describe("keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.") |
| .describe("quotes", "Quote style (0 - auto, 1 - single, 2 - double, 3 - original)") |
| .describe("reserved-file", "File containing reserved names") |
| .describe("reserve-domprops", "Make (most?) DOM properties reserved for --mangle-props") |
| .describe("mangle-props", "Mangle property names (0 - disabled, 1 - mangle all properties, 2 - mangle unquoted properies)") |
| .describe("mangle-regex", "Only mangle property names matching the regex") |
| .describe("name-cache", "File to hold mangled names mappings") |
| .describe("pure-funcs", "List of functions that can be safely removed if their return value is not used") |
| .describe("dump-spidermonkey-ast", "Dump SpiderMonkey AST to stdout.") |
| .describe("wrap-iife", "Wrap IIFEs in parenthesis. Note: this disables the negate_iife compression option") |
| |
| .alias("p", "prefix") |
| .alias("o", "output") |
| .alias("v", "verbose") |
| .alias("b", "beautify") |
| .alias("m", "mangle") |
| .alias("c", "compress") |
| .alias("d", "define") |
| .alias("r", "reserved") |
| .alias("V", "version") |
| .alias("e", "enclose") |
| .alias("q", "quotes") |
| |
| .string("source-map") |
| .string("source-map-root") |
| .string("source-map-url") |
| .string("b") |
| .string("beautify") |
| .string("m") |
| .string("mangle") |
| .string("mangle-props-debug") |
| .string("c") |
| .string("compress") |
| .string("d") |
| .string("define") |
| .string("e") |
| .string("enclose") |
| .string("comments") |
| .string("wrap") |
| .string("p") |
| .string("prefix") |
| .string("name-cache") |
| |
| .array("reserved-file") |
| .array("pure-funcs") |
| |
| .boolean("expr") |
| .boolean("source-map-inline") |
| .boolean("source-map-include-sources") |
| .boolean("screw-ie8") |
| .boolean("support-ie8") |
| .boolean("export-all") |
| .boolean("self") |
| .boolean("v") |
| .boolean("verbose") |
| .boolean("stats") |
| .boolean("acorn") |
| .boolean("spidermonkey") |
| .boolean("dump-spidermonkey-ast") |
| .boolean("lint") |
| .boolean("V") |
| .boolean("version") |
| .boolean("noerr") |
| .boolean("bare-returns") |
| .boolean("keep-fnames") |
| .boolean("reserve-domprops") |
| .boolean("wrap-iife") |
| |
| .wrap(80) |
| |
| .argv |
| ; |
| |
| normalize(ARGS); |
| |
| if (ARGS.noerr) { |
| UglifyJS.DefaultsError.croak = function(msg, defs) { |
| print_error("WARN: " + msg); |
| }; |
| } |
| |
| if (ARGS.version || ARGS.V) { |
| var json = require("../package.json"); |
| print(json.name + ' ' + json.version); |
| process.exit(0); |
| } |
| |
| if (ARGS.ast_help) { |
| var desc = UglifyJS.describe_ast(); |
| print(typeof desc == "string" ? desc : JSON.stringify(desc, null, 2)); |
| process.exit(0); |
| } |
| |
| if (ARGS.h || ARGS.help) { |
| print(yargs.help()); |
| process.exit(0); |
| } |
| |
| if (ARGS.acorn) { |
| acorn = require("acorn"); |
| } |
| |
| var COMPRESS = getOptions("c", true); |
| var MANGLE = getOptions("m", true); |
| var BEAUTIFY = getOptions("b", true); |
| var RESERVED = null; |
| |
| if (ARGS.reserved_file) ARGS.reserved_file.forEach(function(filename){ |
| RESERVED = UglifyJS.readReservedFile(filename, RESERVED); |
| }); |
| |
| if (ARGS.reserve_domprops) { |
| RESERVED = UglifyJS.readDefaultReservedFile(RESERVED); |
| } |
| |
| if (ARGS.d) { |
| if (COMPRESS) COMPRESS.global_defs = getOptions("d"); |
| } |
| |
| if (ARGS.pure_funcs) { |
| if (COMPRESS) COMPRESS.pure_funcs = ARGS.pure_funcs; |
| } |
| |
| if (ARGS.r) { |
| if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/); |
| } |
| |
| if (RESERVED && MANGLE) { |
| if (!MANGLE.except) MANGLE.except = RESERVED.vars; |
| else MANGLE.except = MANGLE.except.concat(RESERVED.vars); |
| } |
| |
| function readNameCache(key) { |
| return UglifyJS.readNameCache(ARGS.name_cache, key); |
| } |
| |
| function writeNameCache(key, cache) { |
| return UglifyJS.writeNameCache(ARGS.name_cache, key, cache); |
| } |
| |
| function extractRegex(str) { |
| if (/^\/.*\/[a-zA-Z]*$/.test(str)) { |
| var regex_pos = str.lastIndexOf("/"); |
| return new RegExp(str.substr(1, regex_pos - 1), str.substr(regex_pos + 1)); |
| } else { |
| throw new Error("Invalid regular expression: " + str); |
| } |
| } |
| |
| if (ARGS.quotes === true) { |
| ARGS.quotes = 3; |
| } |
| |
| if (ARGS.mangle_props === true) { |
| ARGS.mangle_props = 1; |
| } else if (ARGS.mangle_props === "unquoted") { |
| ARGS.mangle_props = 2; |
| } |
| |
| var OUTPUT_OPTIONS = { |
| beautify : BEAUTIFY ? true : false, |
| max_line_len : 32000, |
| preamble : ARGS.preamble || null, |
| quote_style : ARGS.quotes != null ? ARGS.quotes : 0, |
| }; |
| |
| if (ARGS.mangle_props == 2) { |
| OUTPUT_OPTIONS.keep_quoted_props = true; |
| if (COMPRESS && !("properties" in COMPRESS)) |
| COMPRESS.properties = false; |
| } |
| |
| if (ARGS.support_ie8 === true && ARGS.screw_ie8 !== true) { |
| screw_ie8 = false; |
| } |
| |
| if (COMPRESS) COMPRESS.screw_ie8 = screw_ie8; |
| if (MANGLE) MANGLE.screw_ie8 = screw_ie8; |
| OUTPUT_OPTIONS.screw_ie8 = screw_ie8; |
| |
| if (ARGS.keep_fnames) { |
| if (COMPRESS) COMPRESS.keep_fnames = true; |
| if (MANGLE) MANGLE.keep_fnames = true; |
| } |
| |
| if (ARGS.wrap_iife) { |
| if (COMPRESS) COMPRESS.negate_iife = false; |
| OUTPUT_OPTIONS.wrap_iife = true; |
| } |
| |
| if (BEAUTIFY) |
| UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY); |
| |
| if (ARGS.comments === "") { |
| OUTPUT_OPTIONS.comments = "some"; |
| } else { |
| OUTPUT_OPTIONS.comments = ARGS.comments; |
| } |
| |
| var files = ARGS._.slice(); |
| |
| if (process.platform === "win32") |
| files = UglifyJS.simple_glob(files); |
| |
| if (ARGS.self) { |
| if (files.length > 0) { |
| print_error("WARN: Ignoring input files since --self was passed"); |
| } |
| files = UglifyJS.FILES; |
| if (!ARGS.wrap) ARGS.wrap = "UglifyJS"; |
| } |
| |
| var ORIG_MAP = ARGS.in_source_map; |
| |
| if (ORIG_MAP && ORIG_MAP != "inline") { |
| ORIG_MAP = JSON.parse(fs.readFileSync(ORIG_MAP)); |
| if (files.length == 0) { |
| print_error("INFO: Using file from the input source map: " + ORIG_MAP.file); |
| files = [ ORIG_MAP.file ]; |
| } |
| } |
| |
| if (files.length == 0) { |
| files = [ "-" ]; |
| } |
| |
| if (ORIG_MAP == "inline") { |
| if (files.length > 1) { |
| print_error("ERROR: Inline source map only works with singular input"); |
| process.exit(1); |
| } |
| if (ARGS.acorn || ARGS.spidermonkey) { |
| print_error("ERROR: Inline source map only works with built-in parser"); |
| process.exit(1); |
| } |
| } |
| |
| if (files.indexOf("-") >= 0 && ARGS.source_map) { |
| print_error("ERROR: Source map doesn't work with input from STDIN"); |
| process.exit(1); |
| } |
| |
| if (files.filter(function(el){ return el == "-" }).length > 1) { |
| print_error("ERROR: Can read a single file from STDIN (two or more dashes specified)"); |
| process.exit(1); |
| } |
| |
| var STATS = {}; |
| var TOPLEVEL = null; |
| var P_RELATIVE = ARGS.p && ARGS.p == "relative"; |
| var SOURCES_CONTENT = {}; |
| var index = 0; |
| |
| !function cb() { |
| if (index == files.length) return done(); |
| var file = files[index++]; |
| read_whole_file(file, function (err, code) { |
| if (err) { |
| print_error("ERROR: can't read file: " + file); |
| process.exit(1); |
| } |
| if (ORIG_MAP == "inline") { |
| ORIG_MAP = read_source_map(code); |
| } |
| if (ARGS.p != null) { |
| if (P_RELATIVE) { |
| file = path.relative(path.dirname(ARGS.source_map), file).replace(/\\/g, '/'); |
| } else { |
| var p = parseInt(ARGS.p, 10); |
| if (!isNaN(p)) { |
| file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/"); |
| } |
| } |
| } |
| SOURCES_CONTENT[file] = code; |
| time_it("parse", function(){ |
| if (ARGS.spidermonkey) { |
| var program = JSON.parse(code); |
| if (!TOPLEVEL) TOPLEVEL = program; |
| else TOPLEVEL.body = TOPLEVEL.body.concat(program.body); |
| } |
| else if (ARGS.acorn) { |
| TOPLEVEL = acorn.parse(code, { |
| locations : true, |
| sourceFile : file, |
| program : TOPLEVEL |
| }); |
| } |
| else { |
| try { |
| TOPLEVEL = UglifyJS.parse(code, { |
| filename : file, |
| toplevel : TOPLEVEL, |
| expression : ARGS.expr, |
| bare_returns : ARGS.bare_returns, |
| }); |
| } catch(ex) { |
| if (ex instanceof UglifyJS.JS_Parse_Error) { |
| print_error("Parse error at " + file + ":" + ex.line + "," + ex.col); |
| var col = ex.col; |
| var lines = code.split(/\r?\n/); |
| var line = lines[ex.line - 1]; |
| if (!line && !col) { |
| line = lines[ex.line - 2]; |
| col = line.length; |
| } |
| if (line) { |
| if (col > 40) { |
| line = line.slice(col - 40); |
| col = 40; |
| } |
| print_error(line.slice(0, 80)); |
| print_error(line.slice(0, col).replace(/\S/g, " ") + "^"); |
| } |
| print_error(ex.stack); |
| process.exit(1); |
| } |
| throw ex; |
| } |
| }; |
| }); |
| cb(); |
| }); |
| }(); |
| |
| function done() { |
| var OUTPUT_FILE = ARGS.o; |
| |
| var SOURCE_MAP = (ARGS.source_map || ARGS.source_map_inline) ? UglifyJS.SourceMap({ |
| file: P_RELATIVE ? path.relative(path.dirname(ARGS.source_map), OUTPUT_FILE) : OUTPUT_FILE, |
| root: ARGS.source_map_root || ORIG_MAP && ORIG_MAP.sourceRoot, |
| orig: ORIG_MAP, |
| }) : null; |
| |
| OUTPUT_OPTIONS.source_map = SOURCE_MAP; |
| |
| try { |
| var output = UglifyJS.OutputStream(OUTPUT_OPTIONS); |
| var compressor = COMPRESS && UglifyJS.Compressor(COMPRESS); |
| } catch(ex) { |
| if (ex instanceof UglifyJS.DefaultsError) { |
| print_error(ex.message); |
| print_error("Supported options:"); |
| print_error(sys.inspect(ex.defs)); |
| process.exit(1); |
| } |
| } |
| |
| if (ARGS.acorn || ARGS.spidermonkey) time_it("convert_ast", function(){ |
| TOPLEVEL = UglifyJS.AST_Node.from_mozilla_ast(TOPLEVEL); |
| }); |
| |
| if (ARGS.wrap != null) { |
| TOPLEVEL = TOPLEVEL.wrap_commonjs(ARGS.wrap, ARGS.export_all); |
| } |
| |
| if (ARGS.enclose != null) { |
| var arg_parameter_list = ARGS.enclose; |
| if (arg_parameter_list === true) { |
| arg_parameter_list = []; |
| } |
| else if (!(arg_parameter_list instanceof Array)) { |
| arg_parameter_list = [arg_parameter_list]; |
| } |
| TOPLEVEL = TOPLEVEL.wrap_enclose(arg_parameter_list); |
| } |
| |
| if (ARGS.mangle_props || ARGS.name_cache) (function(){ |
| var reserved = RESERVED ? RESERVED.props : null; |
| var cache = readNameCache("props"); |
| var regex; |
| |
| try { |
| regex = ARGS.mangle_regex ? extractRegex(ARGS.mangle_regex) : null; |
| } catch (e) { |
| print_error("ERROR: Invalid --mangle-regex: " + e.message); |
| process.exit(1); |
| } |
| |
| TOPLEVEL = UglifyJS.mangle_properties(TOPLEVEL, { |
| reserved : reserved, |
| cache : cache, |
| only_cache : !ARGS.mangle_props, |
| regex : regex, |
| ignore_quoted : ARGS.mangle_props == 2, |
| debug : typeof ARGS.mangle_props_debug === "undefined" ? false : ARGS.mangle_props_debug |
| }); |
| writeNameCache("props", cache); |
| })(); |
| |
| var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint |
| var TL_CACHE = readNameCache("vars"); |
| if (MANGLE) MANGLE.cache = TL_CACHE; |
| |
| if (SCOPE_IS_NEEDED) { |
| time_it("scope", function(){ |
| TOPLEVEL.figure_out_scope(MANGLE || { screw_ie8: screw_ie8, cache: TL_CACHE }); |
| if (ARGS.lint) { |
| TOPLEVEL.scope_warnings(); |
| } |
| }); |
| } |
| |
| if (COMPRESS) { |
| time_it("squeeze", function(){ |
| TOPLEVEL = compressor.compress(TOPLEVEL); |
| }); |
| } |
| |
| if (SCOPE_IS_NEEDED) { |
| time_it("scope", function(){ |
| TOPLEVEL.figure_out_scope(MANGLE || { screw_ie8: screw_ie8, cache: TL_CACHE }); |
| if (MANGLE && !TL_CACHE) { |
| TOPLEVEL.compute_char_frequency(MANGLE); |
| } |
| }); |
| } |
| |
| if (MANGLE) time_it("mangle", function(){ |
| TOPLEVEL.mangle_names(MANGLE); |
| }); |
| |
| writeNameCache("vars", TL_CACHE); |
| |
| if (ARGS.source_map_include_sources) { |
| for (var file in SOURCES_CONTENT) { |
| if (SOURCES_CONTENT.hasOwnProperty(file)) { |
| SOURCE_MAP.get().setSourceContent(file, SOURCES_CONTENT[file]); |
| } |
| } |
| } |
| |
| if (ARGS.dump_spidermonkey_ast) { |
| print(JSON.stringify(TOPLEVEL.to_mozilla_ast(), null, 2)); |
| } else { |
| time_it("generate", function(){ |
| TOPLEVEL.print(output); |
| }); |
| |
| output = output.get(); |
| |
| if (SOURCE_MAP) { |
| if (ARGS.source_map_inline) { |
| var base64_string = new Buffer(SOURCE_MAP.toString()).toString('base64'); |
| output += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + base64_string; |
| } else { |
| fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8"); |
| var source_map_url = ARGS.source_map_url || ( |
| P_RELATIVE |
| ? path.relative(path.dirname(OUTPUT_FILE), ARGS.source_map) |
| : ARGS.source_map |
| ); |
| output += "\n//# sourceMappingURL=" + source_map_url; |
| } |
| } |
| |
| if (OUTPUT_FILE) { |
| fs.writeFileSync(OUTPUT_FILE, output, "utf8"); |
| } else { |
| print(output); |
| } |
| } |
| |
| if (ARGS.stats) { |
| print_error(UglifyJS.string_template("Timing information (compressed {count} files):", { |
| count: files.length |
| })); |
| for (var i in STATS) if (STATS.hasOwnProperty(i)) { |
| print_error(UglifyJS.string_template("- {name}: {time}s", { |
| name: i, |
| time: (STATS[i] / 1000).toFixed(3) |
| })); |
| } |
| } |
| } |
| |
| /* -----[ functions ]----- */ |
| |
| function normalize(o) { |
| for (var i in o) if (o.hasOwnProperty(i) && /-/.test(i)) { |
| o[i.replace(/-/g, "_")] = o[i]; |
| delete o[i]; |
| } |
| } |
| |
| function getOptions(flag, constants) { |
| var x = ARGS[flag]; |
| if (x == null || x === false) return null; |
| var ret = {}; |
| if (x !== "") { |
| if (Array.isArray(x)) x = x.map(function (v) { return "(" + v + ")"; }).join(", "); |
| |
| var ast; |
| try { |
| ast = UglifyJS.parse(x, { cli: true, expression: true }); |
| } catch(ex) { |
| if (ex instanceof UglifyJS.JS_Parse_Error) { |
| print_error("Error parsing arguments for flag `" + flag + "': " + x); |
| process.exit(1); |
| } |
| } |
| ast.walk(new UglifyJS.TreeWalker(function(node){ |
| if (node instanceof UglifyJS.AST_Seq) return; // descend |
| if (node instanceof UglifyJS.AST_Assign) { |
| var name = node.left.print_to_string().replace(/-/g, "_"); |
| var value = node.right; |
| if (constants) |
| value = new Function("return (" + value.print_to_string() + ")")(); |
| ret[name] = value; |
| return true; // no descend |
| } |
| if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_Binary) { |
| var name = node.print_to_string().replace(/-/g, "_"); |
| ret[name] = true; |
| return true; // no descend |
| } |
| print_error(node.TYPE) |
| print_error("Error parsing arguments for flag `" + flag + "': " + x); |
| process.exit(1); |
| })); |
| } |
| return ret; |
| } |
| |
| function read_whole_file(filename, cb) { |
| if (filename == "-") { |
| var chunks = []; |
| process.stdin.setEncoding('utf-8'); |
| process.stdin.on('data', function (chunk) { |
| chunks.push(chunk); |
| }).on('end', function () { |
| cb(null, chunks.join("")); |
| }); |
| process.openStdin(); |
| } else { |
| fs.readFile(filename, "utf-8", cb); |
| } |
| } |
| |
| function read_source_map(code) { |
| var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code); |
| if (!match) { |
| print_error("WARN: inline source map not found"); |
| return null; |
| } |
| return JSON.parse(new Buffer(match[2], "base64")); |
| } |
| |
| function time_it(name, cont) { |
| var t1 = new Date().getTime(); |
| var ret = cont(); |
| if (ARGS.stats) { |
| var spent = new Date().getTime() - t1; |
| if (STATS[name]) STATS[name] += spent; |
| else STATS[name] = spent; |
| } |
| return ret; |
| } |
| |
| function print_error(msg) { |
| console.error("%s", msg); |
| } |
| |
| function print(txt) { |
| console.log("%s", txt); |
| } |