| /*********************************************************************** | |
| A JavaScript tokenizer / parser / beautifier / compressor. | |
| https://github.com/mishoo/UglifyJS2 | |
| -------------------------------- (C) --------------------------------- | |
| Author: Mihai Bazon | |
| <mihai.bazon@gmail.com> | |
| http://mihai.bazon.net/blog | |
| Distributed under the BSD license: | |
| Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com> | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions | |
| are met: | |
| * Redistributions of source code must retain the above | |
| copyright notice, this list of conditions and the following | |
| disclaimer. | |
| * Redistributions in binary form must reproduce the above | |
| copyright notice, this list of conditions and the following | |
| disclaimer in the documentation and/or other materials | |
| provided with the distribution. | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY | |
| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE | |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, | |
| OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
| PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR | |
| TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF | |
| THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
| SUCH DAMAGE. | |
| ***********************************************************************/ | |
| "use strict"; | |
| function find_builtins(reserved) { | |
| // NaN will be included due to Number.NaN | |
| [ | |
| "null", | |
| "true", | |
| "false", | |
| "Infinity", | |
| "-Infinity", | |
| "undefined", | |
| ].forEach(add); | |
| [ | |
| Array, | |
| Boolean, | |
| Date, | |
| Error, | |
| Function, | |
| Math, | |
| Number, | |
| Object, | |
| RegExp, | |
| String, | |
| ].forEach(function(ctor) { | |
| Object.getOwnPropertyNames(ctor).map(add); | |
| if (ctor.prototype) { | |
| Object.getOwnPropertyNames(ctor.prototype).map(add); | |
| } | |
| }); | |
| function add(name) { | |
| push_uniq(reserved, name); | |
| } | |
| } | |
| function reserve_quoted_keys(ast, reserved) { | |
| ast.walk(new TreeWalker(function(node) { | |
| if (node instanceof AST_ObjectKeyVal && node.quote) { | |
| add(node.key); | |
| } else if (node instanceof AST_Sub) { | |
| addStrings(node.property, add); | |
| } | |
| })); | |
| function add(name) { | |
| push_uniq(reserved, name); | |
| } | |
| } | |
| function addStrings(node, add) { | |
| node.walk(new TreeWalker(function(node) { | |
| if (node instanceof AST_Sequence) { | |
| addStrings(node.tail_node(), add); | |
| } else if (node instanceof AST_String) { | |
| add(node.value); | |
| } else if (node instanceof AST_Conditional) { | |
| addStrings(node.consequent, add); | |
| addStrings(node.alternative, add); | |
| } | |
| return true; | |
| })); | |
| } | |
| function mangle_properties(ast, options) { | |
| options = defaults(options, { | |
| builtins: false, | |
| cache: null, | |
| debug: false, | |
| keep_quoted: false, | |
| only_cache: false, | |
| regex: null, | |
| reserved: null, | |
| }, true); | |
| var reserved = options.reserved; | |
| if (!Array.isArray(reserved)) reserved = []; | |
| if (!options.builtins) find_builtins(reserved); | |
| var cname = -1; | |
| var cache; | |
| if (options.cache) { | |
| cache = options.cache.props; | |
| cache.each(function(mangled_name) { | |
| push_uniq(reserved, mangled_name); | |
| }); | |
| } else { | |
| cache = new Dictionary(); | |
| } | |
| var regex = options.regex; | |
| // note debug is either false (disabled), or a string of the debug suffix to use (enabled). | |
| // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true' | |
| // the same as passing an empty string. | |
| var debug = options.debug !== false; | |
| var debug_suffix; | |
| if (debug) debug_suffix = options.debug === true ? "" : options.debug; | |
| var names_to_mangle = []; | |
| var unmangleable = []; | |
| // step 1: find candidates to mangle | |
| ast.walk(new TreeWalker(function(node) { | |
| if (node instanceof AST_ObjectKeyVal) { | |
| add(node.key); | |
| } else if (node instanceof AST_ObjectProperty) { | |
| // setter or getter, since KeyVal is handled above | |
| add(node.key.name); | |
| } else if (node instanceof AST_Dot) { | |
| add(node.property); | |
| } else if (node instanceof AST_Sub) { | |
| addStrings(node.property, add); | |
| } else if (node instanceof AST_Call | |
| && node.expression.print_to_string() == "Object.defineProperty") { | |
| addStrings(node.args[1], add); | |
| } | |
| })); | |
| // step 2: transform the tree, renaming properties | |
| return ast.transform(new TreeTransformer(function(node) { | |
| if (node instanceof AST_ObjectKeyVal) { | |
| node.key = mangle(node.key); | |
| } else if (node instanceof AST_ObjectProperty) { | |
| // setter or getter | |
| node.key.name = mangle(node.key.name); | |
| } else if (node instanceof AST_Dot) { | |
| node.property = mangle(node.property); | |
| } else if (!options.keep_quoted && node instanceof AST_Sub) { | |
| node.property = mangleStrings(node.property); | |
| } else if (node instanceof AST_Call | |
| && node.expression.print_to_string() == "Object.defineProperty") { | |
| node.args[1] = mangleStrings(node.args[1]); | |
| } | |
| })); | |
| // only function declarations after this line | |
| function can_mangle(name) { | |
| if (unmangleable.indexOf(name) >= 0) return false; | |
| if (reserved.indexOf(name) >= 0) return false; | |
| if (options.only_cache) return cache.has(name); | |
| if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false; | |
| return true; | |
| } | |
| function should_mangle(name) { | |
| if (regex && !regex.test(name)) return false; | |
| if (reserved.indexOf(name) >= 0) return false; | |
| return cache.has(name) || names_to_mangle.indexOf(name) >= 0; | |
| } | |
| function add(name) { | |
| if (can_mangle(name)) push_uniq(names_to_mangle, name); | |
| if (!should_mangle(name)) push_uniq(unmangleable, name); | |
| } | |
| function mangle(name) { | |
| if (!should_mangle(name)) { | |
| return name; | |
| } | |
| var mangled = cache.get(name); | |
| if (!mangled) { | |
| if (debug) { | |
| // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_. | |
| var debug_mangled = "_$" + name + "$" + debug_suffix + "_"; | |
| if (can_mangle(debug_mangled)) mangled = debug_mangled; | |
| } | |
| // either debug mode is off, or it is on and we could not use the mangled name | |
| if (!mangled) do { | |
| mangled = base54(++cname); | |
| } while (!can_mangle(mangled)); | |
| cache.set(name, mangled); | |
| } | |
| return mangled; | |
| } | |
| function mangleStrings(node) { | |
| return node.transform(new TreeTransformer(function(node) { | |
| if (node instanceof AST_Sequence) { | |
| var last = node.expressions.length - 1; | |
| node.expressions[last] = mangleStrings(node.expressions[last]); | |
| } else if (node instanceof AST_String) { | |
| node.value = mangle(node.value); | |
| } else if (node instanceof AST_Conditional) { | |
| node.consequent = mangleStrings(node.consequent); | |
| node.alternative = mangleStrings(node.alternative); | |
| } | |
| return node; | |
| })); | |
| } | |
| } |