You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
264 lines
8.7 KiB
264 lines
8.7 KiB
/*********************************************************************** |
|
|
|
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() { |
|
// NaN will be included due to Number.NaN |
|
var a = [ |
|
"null", |
|
"true", |
|
"false", |
|
"Infinity", |
|
"-Infinity", |
|
"undefined", |
|
]; |
|
[ Object, Array, Function, Number, |
|
String, Boolean, Error, Math, |
|
Date, RegExp |
|
].forEach(function(ctor){ |
|
Object.getOwnPropertyNames(ctor).map(add); |
|
if (ctor.prototype) { |
|
Object.getOwnPropertyNames(ctor.prototype).map(add); |
|
} |
|
}); |
|
function add(name) { |
|
push_uniq(a, name); |
|
} |
|
return a; |
|
} |
|
|
|
function mangle_properties(ast, options) { |
|
options = defaults(options, { |
|
cache: null, |
|
debug: false, |
|
ignore_quoted: false, |
|
only_cache: false, |
|
regex: null, |
|
reserved: null, |
|
}); |
|
|
|
var reserved = options.reserved; |
|
if (reserved == null) |
|
reserved = find_builtins(); |
|
|
|
var cache = options.cache; |
|
if (cache == null) { |
|
cache = { |
|
cname: -1, |
|
props: new Dictionary() |
|
}; |
|
} |
|
|
|
var regex = options.regex; |
|
var ignore_quoted = options.ignore_quoted; |
|
|
|
// 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_name_suffix; |
|
if (debug) { |
|
debug_name_suffix = (options.debug === true ? "" : options.debug); |
|
} |
|
|
|
var names_to_mangle = []; |
|
var unmangleable = []; |
|
var ignored = {}; |
|
|
|
// step 1: find candidates to mangle |
|
ast.walk(new TreeWalker(function(node){ |
|
if (node instanceof AST_ObjectKeyVal) { |
|
add(node.key, ignore_quoted && node.quote); |
|
} |
|
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, ignore_quoted); |
|
} |
|
})); |
|
|
|
// step 2: transform the tree, renaming properties |
|
return ast.transform(new TreeTransformer(function(node){ |
|
if (node instanceof AST_ObjectKeyVal) { |
|
if (!(ignore_quoted && node.quote)) |
|
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 (node instanceof AST_Sub) { |
|
if (!ignore_quoted) |
|
node.property = mangleStrings(node.property); |
|
} |
|
// else if (node instanceof AST_String) { |
|
// if (should_mangle(node.value)) { |
|
// AST_Node.warn( |
|
// "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", { |
|
// file : node.start.file, |
|
// line : node.start.line, |
|
// col : node.start.col, |
|
// prop : node.value |
|
// } |
|
// ); |
|
// } |
|
// } |
|
})); |
|
|
|
// 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.props.has(name); |
|
} |
|
if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false; |
|
return true; |
|
} |
|
|
|
function should_mangle(name) { |
|
if (ignore_quoted && name in ignored) return false; |
|
if (regex && !regex.test(name)) return false; |
|
if (reserved.indexOf(name) >= 0) return false; |
|
return cache.props.has(name) |
|
|| names_to_mangle.indexOf(name) >= 0; |
|
} |
|
|
|
function add(name, ignore) { |
|
if (ignore) { |
|
ignored[name] = true; |
|
return; |
|
} |
|
|
|
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.props.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_name_suffix + "_"; |
|
|
|
if (can_mangle(debug_mangled) && !(ignore_quoted && debug_mangled in ignored)) { |
|
mangled = debug_mangled; |
|
} |
|
} |
|
|
|
// either debug mode is off, or it is on and we could not use the mangled name |
|
if (!mangled) { |
|
// note can_mangle() does not check if the name collides with the 'ignored' set |
|
// (filled with quoted properties when ignore_quoted set). Make sure we add this |
|
// check so we don't collide with a quoted name. |
|
do { |
|
mangled = base54(++cache.cname); |
|
} while (!can_mangle(mangled) || (ignore_quoted && mangled in ignored)); |
|
} |
|
|
|
cache.props.set(name, mangled); |
|
} |
|
return mangled; |
|
} |
|
|
|
function addStrings(node, ignore) { |
|
var out = {}; |
|
try { |
|
(function walk(node){ |
|
node.walk(new TreeWalker(function(node){ |
|
if (node instanceof AST_Seq) { |
|
walk(node.cdr); |
|
return true; |
|
} |
|
if (node instanceof AST_String) { |
|
add(node.value, ignore); |
|
return true; |
|
} |
|
if (node instanceof AST_Conditional) { |
|
walk(node.consequent); |
|
walk(node.alternative); |
|
return true; |
|
} |
|
throw out; |
|
})); |
|
})(node); |
|
} catch(ex) { |
|
if (ex !== out) throw ex; |
|
} |
|
} |
|
|
|
function mangleStrings(node) { |
|
return node.transform(new TreeTransformer(function(node){ |
|
if (node instanceof AST_Seq) { |
|
node.cdr = mangleStrings(node.cdr); |
|
} |
|
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; |
|
})); |
|
} |
|
|
|
}
|
|
|