636 lines
21 KiB
Plaintext
636 lines
21 KiB
Plaintext
|
#! /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);
|
||
|
|
}
|