wallet-core/node_modules/uglify-js/bin/uglifyjs

#! /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);
}