c7f5c6b36b
list of names that are not o be assigned to vars during mangle/propmangle. added javascript reserved words as default. This fixes current issue that in some constalations uglify-js mangles properties to js reserved words e.g. if
320 lines
12 KiB
JavaScript
320 lines
12 KiB
JavaScript
/***********************************************************************
|
|
|
|
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() {
|
|
var a = [];
|
|
[ 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 find_js_reserved_words() {
|
|
return ["abstract", "else", "instanceof", "super",
|
|
"boolean", "enum", "int", "switch",
|
|
"break", "export", "interface", "synchronized",
|
|
"byte", "extends", "let", "this",
|
|
"case", "false", "long", "throw",
|
|
"catch", "final", "native", "throws",
|
|
"char", "finally", "new", "transient",
|
|
"class", "float", "null", "true",
|
|
"const", "for", "package", "try",
|
|
"continue", "function", "private", "typeof",
|
|
"debugger", "goto", "protected", "var",
|
|
"default", "if", "public", "void",
|
|
"delete", "implements", "return", "volatile",
|
|
"do", "import", "short", "while",
|
|
"double", "in", "static", "with", "alert", "frames", "outerHeight",
|
|
"all", "frameRate", "outerWidth",
|
|
"anchor", "function", "packages",
|
|
"anchors", "getClass", "pageXOffset",
|
|
"area", "hasOwnProperty", "pageYOffset",
|
|
"Array", "hidden", "parent",
|
|
"assign", "history", "parseFloat",
|
|
"blur", "image", "parseInt",
|
|
"button", "images", "password",
|
|
"checkbox", "Infinity", "pkcs11",
|
|
"clearInterval", "isFinite", "plugin",
|
|
"clearTimeout", "isNaN", "prompt",
|
|
"clientInformation", "isPrototypeOf", "propertyIsEnum",
|
|
"close", "java", "prototype",
|
|
"closed", "JavaArray", "radio",
|
|
"confirm", "JavaClass", "reset",
|
|
"constructor", "JavaObject", "screenX",
|
|
"crypto", "JavaPackage", "screenY",
|
|
"Date", "innerHeight", "scroll",
|
|
"decodeURI", "innerWidth", "secure",
|
|
"decodeURIComponent", "layer", "select",
|
|
"defaultStatus", "layers", "self",
|
|
"document", "length", "setInterval",
|
|
"element", "link", "setTimeout",
|
|
"elements", "location", "status",
|
|
"embed", "Math", "String",
|
|
"embeds", "mimeTypes", "submit",
|
|
"encodeURI", "name", "taint",
|
|
"encodeURIComponent", "NaN", "text",
|
|
"escape", "navigate", "textarea",
|
|
"eval", "navigator", "top",
|
|
"event", "Number", "toString",
|
|
"fileUpload", "Object", "undefined",
|
|
"focus", "offscreenBuffering", "unescape",
|
|
"form", "open", "untaint",
|
|
"forms", "opener", "valueOf",
|
|
"frame", "option", "window", "onbeforeunload", "ondragdrop", "onkeyup", "onmouseover",
|
|
"onblur", "onerror", "onload", "onmouseup",
|
|
"ondragdrop", "onfocus", "onmousedown", "onreset",
|
|
"onclick", "onkeydown", "onmousemove", "onsubmit",
|
|
"oncontextmenu", "onkeypress", "onmouseout", "onunload"];
|
|
}
|
|
|
|
function mangle_properties(ast, options) {
|
|
options = defaults(options, {
|
|
reserved : null,
|
|
cache : null,
|
|
only_cache : false,
|
|
regex : null,
|
|
ignore_quoted : false,
|
|
illegal_mangled_names: null,
|
|
debug : false
|
|
});
|
|
|
|
var reserved = options.reserved;
|
|
if (reserved == null)
|
|
reserved = find_builtins();
|
|
var illegal_mangled_names = options.illegal_mangled_names;
|
|
if (illegal_mangled_names == null)
|
|
illegal_mangled_names = find_js_reserved_words();
|
|
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 = {};
|
|
|
|
if (illegal_mangled_names) {
|
|
unmangleable = unmangleable.concat(illegal_mangled_names);
|
|
}
|
|
// 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.]+$/.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;
|
|
}));
|
|
}
|
|
|
|
}
|