var tmp = nick;
prefix = tmp.charAt(0);
- if (typeof gateway.user_prefixes[prefix] != "undefined") tmp = tmp.substring(1);
-
+ for(var i in gateway.user_prefixes){
+ if(gateway.user_prefixes[i].symbol !== prefix) continue;
+ return tmp.substring(1);
+ }
+
return tmp;
},
var tmp = nick;
prefix = tmp.charAt(0);
- if (typeof gateway.user_prefixes[prefix] == "undefined") {
- prefix = "";
+ for(var i in gateway.user_prefixes){
+ if(gateway.user_prefixes[i].symbol === prefix){
+ return prefix;
+ }
}
-
- return prefix;
+
+ return '';
},
isChannel: function (name) {
tabview.prototype.addPartImage = function(){
this.clearPartImage();
+ // We can't close this tab, so don't have the close image
+ if(this.name == 'server') return;
+
var del_html = '<img src="img/redcross.png" class="tab_part" />';
this.tab.append(del_html);
front.run("/part");
} else {
// Make sure we don't close the server tab
- if(front.cur_channel.name != "server") front.cur_channel.close();
+ if(front.cur_channel.name != 'server') front.cur_channel.close();
}
});
}
// Sort by prefixes first
for (var i in gateway.user_prefixes) {
- prefix = gateway.user_prefixes[i];
+ prefix = gateway.user_prefixes[i].symbol;
if(compA.charAt(0) == prefix && compB.charAt(0) == prefix){
// Both have the same prefix, string compare time
regex = /\(([^)]*)\)(.*)/;
matches = regex.exec(opt[1]);
if ((matches) && (matches.length === 3)) {
- ircSocket.IRC.options[opt[0]] = {};
+ ircSocket.IRC.options[opt[0]] = [];
for (j = 0; j < matches[2].length; j++) {
- ircSocket.IRC.options[opt[0]][matches[2].charAt(j)] = matches[1].charAt(j);
+ //ircSocket.IRC.options[opt[0]][matches[2].charAt(j)] = matches[1].charAt(j);
+ ircSocket.IRC.options[opt[0]].push({symbol: matches[2].charAt(j), mode: matches[1].charAt(j)});
+ //console.log({symbol: matches[2].charAt(j), mode: matches[1].charAt(j)});
}
+ console.log(ircSocket.IRC.options);
}
}
}
if ((msg.trailing.charAt(0) === '\001') && (msg.trailing.charAt(msg.trailing.length - 1) === '\001')) {
// It's a CTCP request
if (msg.trailing.substr(1, 6) === 'ACTION') {
- websocket.emit('message', {event: 'action', nick: msg.nick, ident: msg.ident, hostname: msg.hostname, channel: msg.params.trim(), msg: msg.trailing.substr(1, msg.trailing.length - 2)});
+ websocket.emit('message', {event: 'action', nick: msg.nick, ident: msg.ident, hostname: msg.hostname, channel: msg.params.trim(), msg: msg.trailing.substr(7, msg.trailing.length - 2)});
} else if (msg.trailing.substr(1, 7) === 'VERSION') {
ircSocket.write('NOTICE ' + msg.nick + ' :\001VERSION KiwiIRC\001\r\n');
} else {
--- /dev/null
+.DS_Store
+.tmp*~
+*.local.*
+.pinf-*
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"
+lang="en" xml:lang="en">
+<head>
+<title>UglifyJS -- a JavaScript parser/compressor/beautifier</title>
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
+<meta name="generator" content="Org-mode"/>
+<meta name="generated" content="2011-07-14 12:50:31 EEST"/>
+<meta name="author" content="Mihai Bazon"/>
+<meta name="description" content="a JavaScript parser/compressor/beautifier in JavaScript"/>
+<meta name="keywords" content="javascript, js, parser, compiler, compressor, mangle, minify, minifier"/>
+<style type="text/css">
+ <!--/*--><![CDATA[/*><!--*/
+ html { font-family: Times, serif; font-size: 12pt; }
+ .title { text-align: center; }
+ .todo { color: red; }
+ .done { color: green; }
+ .tag { background-color: #add8e6; font-weight:normal }
+ .target { }
+ .timestamp { color: #bebebe; }
+ .timestamp-kwd { color: #5f9ea0; }
+ p.verse { margin-left: 3% }
+ pre {
+ border: 1pt solid #AEBDCC;
+ background-color: #F3F5F7;
+ padding: 5pt;
+ font-family: courier, monospace;
+ font-size: 90%;
+ overflow:auto;
+ }
+ table { border-collapse: collapse; }
+ td, th { vertical-align: top; }
+ dt { font-weight: bold; }
+ div.figure { padding: 0.5em; }
+ div.figure p { text-align: center; }
+ textarea { overflow-x: auto; }
+ .linenr { font-size:smaller }
+ .code-highlighted {background-color:#ffff00;}
+ .org-info-js_info-navigation { border-style:none; }
+ #org-info-js_console-label { font-size:10px; font-weight:bold;
+ white-space:nowrap; }
+ .org-info-js_search-highlight {background-color:#ffff00; color:#000000;
+ font-weight:bold; }
+ /*]]>*/-->
+</style>
+<link rel="stylesheet" type="text/css" href="docstyle.css" />
+<script type="text/javascript">
+<!--/*--><![CDATA[/*><!--*/
+ function CodeHighlightOn(elem, id)
+ {
+ var target = document.getElementById(id);
+ if(null != target) {
+ elem.cacheClassElem = elem.className;
+ elem.cacheClassTarget = target.className;
+ target.className = "code-highlighted";
+ elem.className = "code-highlighted";
+ }
+ }
+ function CodeHighlightOff(elem, id)
+ {
+ var target = document.getElementById(id);
+ if(elem.cacheClassElem)
+ elem.className = elem.cacheClassElem;
+ if(elem.cacheClassTarget)
+ target.className = elem.cacheClassTarget;
+ }
+/*]]>*///-->
+</script>
+
+</head>
+<body>
+<div id="content">
+
+<h1 class="title">UglifyJS – a JavaScript parser/compressor/beautifier</h1>
+
+
+<div id="table-of-contents">
+<h2>Table of Contents</h2>
+<div id="text-table-of-contents">
+<ul>
+<li><a href="#sec-1">1 UglifyJS — a JavaScript parser/compressor/beautifier </a>
+<ul>
+<li><a href="#sec-1_1">1.1 Unsafe transformations </a>
+<ul>
+<li><a href="#sec-1_1_1">1.1.1 Calls involving the global Array constructor </a></li>
+</ul>
+</li>
+<li><a href="#sec-1_2">1.2 Install (NPM) </a></li>
+<li><a href="#sec-1_3">1.3 Install latest code from GitHub </a></li>
+<li><a href="#sec-1_4">1.4 Usage </a>
+<ul>
+<li><a href="#sec-1_4_1">1.4.1 API </a></li>
+<li><a href="#sec-1_4_2">1.4.2 Beautifier shortcoming – no more comments </a></li>
+</ul>
+</li>
+<li><a href="#sec-1_5">1.5 Compression – how good is it? </a></li>
+<li><a href="#sec-1_6">1.6 Bugs? </a></li>
+<li><a href="#sec-1_7">1.7 Links </a></li>
+<li><a href="#sec-1_8">1.8 License </a></li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+
+<div id="outline-container-1" class="outline-2">
+<h2 id="sec-1"><span class="section-number-2">1</span> UglifyJS — a JavaScript parser/compressor/beautifier </h2>
+<div class="outline-text-2" id="text-1">
+
+
+<p>
+This package implements a general-purpose JavaScript
+parser/compressor/beautifier toolkit. It is developed on <a href="http://nodejs.org/">NodeJS</a>, but it
+should work on any JavaScript platform supporting the CommonJS module system
+(and if your platform of choice doesn't support CommonJS, you can easily
+implement it, or discard the <code>exports.*</code> lines from UglifyJS sources).
+</p>
+<p>
+The tokenizer/parser generates an abstract syntax tree from JS code. You
+can then traverse the AST to learn more about the code, or do various
+manipulations on it. This part is implemented in <a href="../lib/parse-js.js">parse-js.js</a> and it's a
+port to JavaScript of the excellent <a href="http://marijn.haverbeke.nl/parse-js/">parse-js</a> Common Lisp library from <a href="http://marijn.haverbeke.nl/">Marijn Haverbeke</a>.
+</p>
+<p>
+( See <a href="http://github.com/mishoo/cl-uglify-js">cl-uglify-js</a> if you're looking for the Common Lisp version of
+UglifyJS. )
+</p>
+<p>
+The second part of this package, implemented in <a href="../lib/process.js">process.js</a>, inspects and
+manipulates the AST generated by the parser to provide the following:
+</p>
+<ul>
+<li>
+ability to re-generate JavaScript code from the AST. Optionally
+indented—you can use this if you want to “beautify” a program that has
+been compressed, so that you can inspect the source. But you can also run
+our code generator to print out an AST without any whitespace, so you
+achieve compression as well.
+
+</li>
+<li>
+shorten variable names (usually to single characters). Our mangler will
+analyze the code and generate proper variable names, depending on scope
+and usage, and is smart enough to deal with globals defined elsewhere, or
+with <code>eval()</code> calls or <code>with{}</code> statements. In short, if <code>eval()</code> or
+<code>with{}</code> are used in some scope, then all variables in that scope and any
+variables in the parent scopes will remain unmangled, and any references
+to such variables remain unmangled as well.
+
+</li>
+<li>
+various small optimizations that may lead to faster code but certainly
+lead to smaller code. Where possible, we do the following:
+
+<ul>
+<li>
+foo["bar"] ==> foo.bar
+
+</li>
+<li>
+remove block brackets <code>{}</code>
+
+</li>
+<li>
+join consecutive var declarations:
+var a = 10; var b = 20; ==> var a=10,b=20;
+
+</li>
+<li>
+resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the
+replacement if the result occupies less bytes; for example 1/3 would
+translate to 0.333333333333, so in this case we don't replace it.
+
+</li>
+<li>
+consecutive statements in blocks are merged into a sequence; in many
+cases, this leaves blocks with a single statement, so then we can remove
+the block brackets.
+
+</li>
+<li>
+various optimizations for IF statements:
+
+<ul>
+<li>
+if (foo) bar(); else baz(); ==> foo?bar():baz();
+</li>
+<li>
+if (!foo) bar(); else baz(); ==> foo?baz():bar();
+</li>
+<li>
+if (foo) bar(); ==> foo&&bar();
+</li>
+<li>
+if (!foo) bar(); ==> foo||bar();
+</li>
+<li>
+if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
+</li>
+<li>
+if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+
+</li>
+</ul>
+</li>
+<li>
+remove some unreachable code and warn about it (code that follows a
+<code>return</code>, <code>throw</code>, <code>break</code> or <code>continue</code> statement, except
+function/variable declarations).
+</li>
+</ul>
+</li>
+</ul>
+
+
+
+</div>
+
+<div id="outline-container-1_1" class="outline-3">
+<h3 id="sec-1_1"><span class="section-number-3">1.1</span> <span class="target">Unsafe transformations</span> </h3>
+<div class="outline-text-3" id="text-1_1">
+
+
+<p>
+UglifyJS tries its best to achieve great compression while leaving the
+semantics of the code intact. In general, if your code logic is broken by
+UglifyJS then it's a bug in UglifyJS and you should report it and I should
+fix it. :-)
+</p>
+<p>
+However, I opted to include the following potentially unsafe transformations
+as default behavior. Discussion is welcome, if you have ideas of how to
+handle this better, or any objections to these optimizations, please let me
+know.
+</p>
+
+</div>
+
+<div id="outline-container-1_1_1" class="outline-4">
+<h4 id="sec-1_1_1"><span class="section-number-4">1.1.1</span> Calls involving the global Array constructor </h4>
+<div class="outline-text-4" id="text-1_1_1">
+
+
+<p>
+The following transformations occur:
+</p>
+
+
+
+<pre class="src src-js"><span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3, 4) => [1,2,3,4]
+Array(a, b, c) => [a,b,c]
+<span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(5) => Array(5)
+<span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(a) => Array(a)
+</pre>
+
+
+
+<p>
+These are all safe if the Array name isn't redefined. JavaScript does allow
+one to globally redefine Array (and pretty much everything, in fact) but I
+personally don't see why would anyone do that.
+</p>
+<p>
+UglifyJS does handle the case where Array is redefined locally, or even
+globally but with a <code>function</code> or <code>var</code> declaration. Therefore, in the
+following cases UglifyJS <b>doesn't touch</b> calls or instantiations of Array:
+</p>
+
+
+
+<pre class="src src-js"><span style="color: #00008b;">// </span><span style="color: #00008b;">case 1. globally declared variable
+</span> <span style="color: #8b0000;">var</span> <span style="color: #8b008b;">Array</span>;
+ <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ Array(a, b);
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or (can be declared later)
+</span> <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ <span style="color: #8b0000;">var</span> <span style="color: #8b008b;">Array</span>;
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or (can be a function)
+</span> <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ <span style="color: #8b0000;">function</span> <span style="color: #8b2323;">Array</span>() { ... }
+
+<span style="color: #00008b;">// </span><span style="color: #00008b;">case 2. declared in a function
+</span> (<span style="color: #8b0000;">function</span>(){
+ a = <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ b = Array(5, 6);
+ <span style="color: #8b0000;">var</span> <span style="color: #8b008b;">Array</span>;
+ })();
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or
+</span> (<span style="color: #8b0000;">function</span>(<span style="color: #8b008b;">Array</span>){
+ <span style="color: #8b0000;">return</span> Array(5, 6, 7);
+ })();
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or
+</span> (<span style="color: #8b0000;">function</span>(){
+ <span style="color: #8b0000;">return</span> <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3, 4);
+ <span style="color: #8b0000;">function</span> <span style="color: #8b2323;">Array</span>() { ... }
+ })();
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">etc.
+</span></pre>
+
+
+
+</div>
+</div>
+
+</div>
+
+<div id="outline-container-1_2" class="outline-3">
+<h3 id="sec-1_2"><span class="section-number-3">1.2</span> Install (NPM) </h3>
+<div class="outline-text-3" id="text-1_2">
+
+
+<p>
+UglifyJS is now available through NPM — <code>npm install uglify-js</code> should do
+the job.
+</p>
+</div>
+
+</div>
+
+<div id="outline-container-1_3" class="outline-3">
+<h3 id="sec-1_3"><span class="section-number-3">1.3</span> Install latest code from GitHub </h3>
+<div class="outline-text-3" id="text-1_3">
+
+
+
+
+
+<pre class="src src-sh"><span style="color: #00008b;">## </span><span style="color: #00008b;">clone the repository
+</span>mkdir -p /where/you/wanna/put/it
+<span style="color: #cd0000;">cd</span> /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+<span style="color: #00008b;">## </span><span style="color: #00008b;">make the module available to Node
+</span>mkdir -p ~/.node_libraries/
+<span style="color: #cd0000;">cd</span> ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+<span style="color: #00008b;">## </span><span style="color: #00008b;">and if you want the CLI script too:
+</span>mkdir -p ~/bin
+<span style="color: #cd0000;">cd</span> ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ <span style="color: #00008b;"># </span><span style="color: #00008b;">(then add ~/bin to your $PATH if it's not there already)
+</span></pre>
+
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1_4" class="outline-3">
+<h3 id="sec-1_4"><span class="section-number-3">1.4</span> Usage </h3>
+<div class="outline-text-3" id="text-1_4">
+
+
+<p>
+There is a command-line tool that exposes the functionality of this library
+for your shell-scripting needs:
+</p>
+
+
+
+<pre class="src src-sh">uglifyjs [ options... ] [ filename ]
+</pre>
+
+
+
+<p>
+<code>filename</code> should be the last argument and should name the file from which
+to read the JavaScript code. If you don't specify it, it will read code
+from STDIN.
+</p>
+<p>
+Supported options:
+</p>
+<ul>
+<li>
+<code>-b</code> or <code>--beautify</code> — output indented code; when passed, additional
+options control the beautifier:
+
+<ul>
+<li>
+<code>-i N</code> or <code>--indent N</code> — indentation level (number of spaces)
+
+</li>
+<li>
+<code>-q</code> or <code>--quote-keys</code> — quote keys in literal objects (by default,
+only keys that cannot be identifier names will be quotes).
+
+</li>
+</ul>
+</li>
+<li>
+<code>--ascii</code> — pass this argument to encode non-ASCII characters as
+<code>\uXXXX</code> sequences. By default UglifyJS won't bother to do it and will
+output Unicode characters instead. (the output is always encoded in UTF8,
+but if you pass this option you'll only get ASCII).
+
+</li>
+<li>
+<code>-nm</code> or <code>--no-mangle</code> — don't mangle variable names
+
+</li>
+<li>
+<code>-ns</code> or <code>--no-squeeze</code> — don't call <code>ast_squeeze()</code> (which does various
+optimizations that result in smaller, less readable code).
+
+</li>
+<li>
+<code>-mt</code> or <code>--mangle-toplevel</code> — mangle names in the toplevel scope too
+(by default we don't do this).
+
+</li>
+<li>
+<code>--no-seqs</code> — when <code>ast_squeeze()</code> is called (thus, unless you pass
+<code>--no-squeeze</code>) it will reduce consecutive statements in blocks into a
+sequence. For example, "a = 10; b = 20; foo();" will be written as
+"a=10,b=20,foo();". In various occasions, this allows us to discard the
+block brackets (since the block becomes a single statement). This is ON
+by default because it seems safe and saves a few hundred bytes on some
+libs that I tested it on, but pass <code>--no-seqs</code> to disable it.
+
+</li>
+<li>
+<code>--no-dead-code</code> — by default, UglifyJS will remove code that is
+obviously unreachable (code that follows a <code>return</code>, <code>throw</code>, <code>break</code> or
+<code>continue</code> statement and is not a function/variable declaration). Pass
+this option to disable this optimization.
+
+</li>
+<li>
+<code>-nc</code> or <code>--no-copyright</code> — by default, <code>uglifyjs</code> will keep the initial
+comment tokens in the generated code (assumed to be copyright information
+etc.). If you pass this it will discard it.
+
+</li>
+<li>
+<code>-o filename</code> or <code>--output filename</code> — put the result in <code>filename</code>. If
+this isn't given, the result goes to standard output (or see next one).
+
+</li>
+<li>
+<code>--overwrite</code> — if the code is read from a file (not from STDIN) and you
+pass <code>--overwrite</code> then the output will be written in the same file.
+
+</li>
+<li>
+<code>--ast</code> — pass this if you want to get the Abstract Syntax Tree instead
+of JavaScript as output. Useful for debugging or learning more about the
+internals.
+
+</li>
+<li>
+<code>-v</code> or <code>--verbose</code> — output some notes on STDERR (for now just how long
+each operation takes).
+
+</li>
+<li>
+<code>--extra</code> — enable additional optimizations that have not yet been
+extensively tested. These might, or might not, break your code. If you
+find a bug using this option, please report a test case.
+
+</li>
+<li>
+<code>--unsafe</code> — enable other additional optimizations that are known to be
+unsafe in some contrived situations, but could still be generally useful.
+For now only this:
+
+<ul>
+<li>
+foo.toString() ==> foo+""
+
+</li>
+</ul>
+</li>
+<li>
+<code>--max-line-len</code> (default 32K characters) — add a newline after around
+32K characters. I've seen both FF and Chrome croak when all the code was
+on a single line of around 670K. Pass –max-line-len 0 to disable this
+safety feature.
+
+</li>
+<li>
+<code>--reserved-names</code> — some libraries rely on certain names to be used, as
+pointed out in issue #92 and #81, so this option allow you to exclude such
+names from the mangler. For example, to keep names <code>require</code> and <code>$super</code>
+intact you'd specify –reserved-names "require,$super".
+
+</li>
+<li>
+<code>--inline-script</code> – when you want to include the output literally in an
+HTML <code><script></code> tag you can use this option to prevent <code></script</code> from
+showing up in the output.
+</li>
+</ul>
+
+
+
+</div>
+
+<div id="outline-container-1_4_1" class="outline-4">
+<h4 id="sec-1_4_1"><span class="section-number-4">1.4.1</span> API </h4>
+<div class="outline-text-4" id="text-1_4_1">
+
+
+<p>
+To use the library from JavaScript, you'd do the following (example for
+NodeJS):
+</p>
+
+
+
+<pre class="src src-js"><span style="color: #8b0000;">var</span> <span style="color: #8b008b;">jsp</span> = require(<span style="color: #008b00;">"uglify-js"</span>).parser;
+<span style="color: #8b0000;">var</span> <span style="color: #8b008b;">pro</span> = require(<span style="color: #008b00;">"uglify-js"</span>).uglify;
+
+<span style="color: #8b0000;">var</span> <span style="color: #8b008b;">orig_code</span> = <span style="color: #008b00;">"... JS code here"</span>;
+<span style="color: #8b0000;">var</span> <span style="color: #8b008b;">ast</span> = jsp.parse(orig_code); <span style="color: #00008b;">// </span><span style="color: #00008b;">parse code and get the initial AST
+</span>ast = pro.ast_mangle(ast); <span style="color: #00008b;">// </span><span style="color: #00008b;">get a new AST with mangled names
+</span>ast = pro.ast_squeeze(ast); <span style="color: #00008b;">// </span><span style="color: #00008b;">get an AST with compression optimizations
+</span><span style="color: #8b0000;">var</span> <span style="color: #8b008b;">final_code</span> = pro.gen_code(ast); <span style="color: #00008b;">// </span><span style="color: #00008b;">compressed code here
+</span></pre>
+
+
+
+<p>
+The above performs the full compression that is possible right now. As you
+can see, there are a sequence of steps which you can apply. For example if
+you want compressed output but for some reason you don't want to mangle
+variable names, you would simply skip the line that calls
+<code>pro.ast_mangle(ast)</code>.
+</p>
+<p>
+Some of these functions take optional arguments. Here's a description:
+</p>
+<ul>
+<li>
+<code>jsp.parse(code, strict_semicolons)</code> – parses JS code and returns an AST.
+<code>strict_semicolons</code> is optional and defaults to <code>false</code>. If you pass
+<code>true</code> then the parser will throw an error when it expects a semicolon and
+it doesn't find it. For most JS code you don't want that, but it's useful
+if you want to strictly sanitize your code.
+
+</li>
+<li>
+<code>pro.ast_mangle(ast, options)</code> – generates a new AST containing mangled
+(compressed) variable and function names. It supports the following
+options:
+
+<ul>
+<li>
+<code>toplevel</code> – mangle toplevel names (by default we don't touch them).
+</li>
+<li>
+<code>except</code> – an array of names to exclude from compression.
+
+</li>
+</ul>
+</li>
+<li>
+<code>pro.ast_squeeze(ast, options)</code> – employs further optimizations designed
+to reduce the size of the code that <code>gen_code</code> would generate from the
+AST. Returns a new AST. <code>options</code> can be a hash; the supported options
+are:
+
+<ul>
+<li>
+<code>make_seqs</code> (default true) which will cause consecutive statements in a
+block to be merged using the "sequence" (comma) operator
+
+</li>
+<li>
+<code>dead_code</code> (default true) which will remove unreachable code.
+
+</li>
+</ul>
+</li>
+<li>
+<code>pro.gen_code(ast, options)</code> – generates JS code from the AST. By
+default it's minified, but using the <code>options</code> argument you can get nicely
+formatted output. <code>options</code> is, well, optional :-) and if you pass it it
+must be an object and supports the following properties (below you can see
+the default values):
+
+<ul>
+<li>
+<code>beautify: false</code> – pass <code>true</code> if you want indented output
+</li>
+<li>
+<code>indent_start: 0</code> (only applies when <code>beautify</code> is <code>true</code>) – initial
+indentation in spaces
+</li>
+<li>
+<code>indent_level: 4</code> (only applies when <code>beautify</code> is <code>true</code>) --
+indentation level, in spaces (pass an even number)
+</li>
+<li>
+<code>quote_keys: false</code> – if you pass <code>true</code> it will quote all keys in
+literal objects
+</li>
+<li>
+<code>space_colon: false</code> (only applies when <code>beautify</code> is <code>true</code>) – wether
+to put a space before the colon in object literals
+</li>
+<li>
+<code>ascii_only: false</code> – pass <code>true</code> if you want to encode non-ASCII
+characters as <code>\uXXXX</code>.
+</li>
+<li>
+<code>inline_script: false</code> – pass <code>true</code> to escape occurrences of
+<code></script</code> in strings
+</li>
+</ul>
+</li>
+</ul>
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1_4_2" class="outline-4">
+<h4 id="sec-1_4_2"><span class="section-number-4">1.4.2</span> Beautifier shortcoming – no more comments </h4>
+<div class="outline-text-4" id="text-1_4_2">
+
+
+<p>
+The beautifier can be used as a general purpose indentation tool. It's
+useful when you want to make a minified file readable. One limitation,
+though, is that it discards all comments, so you don't really want to use it
+to reformat your code, unless you don't have, or don't care about, comments.
+</p>
+<p>
+In fact it's not the beautifier who discards comments — they are dumped at
+the parsing stage, when we build the initial AST. Comments don't really
+make sense in the AST, and while we could add nodes for them, it would be
+inconvenient because we'd have to add special rules to ignore them at all
+the processing stages.
+</p>
+</div>
+</div>
+
+</div>
+
+<div id="outline-container-1_5" class="outline-3">
+<h3 id="sec-1_5"><span class="section-number-3">1.5</span> Compression – how good is it? </h3>
+<div class="outline-text-3" id="text-1_5">
+
+
+<p>
+(XXX: this is somewhat outdated. On the jQuery source code we beat Closure
+by 168 bytes (560 after gzip) and by many seconds.)
+</p>
+<p>
+There are a few popular JS minifiers nowadays – the two most well known
+being the GoogleClosure (GCL) compiler and the YUI compressor. For some
+reason they are both written in Java. I didn't really hope to beat any of
+them, but finally I did – UglifyJS compresses better than the YUI
+compressor, and safer than GoogleClosure.
+</p>
+<p>
+I tested it on two big libraries. <a href="http://www.dynarchlib.com/">DynarchLIB</a> is my own, and it's big enough
+to contain probably all the JavaScript tricks known to mankind. <a href="http://jquery.com/">jQuery</a> is
+definitely the most popular JavaScript library (to some people, it's a
+synonym to JavaScript itself).
+</p>
+<p>
+I cannot swear that there are no bugs in the generated codes, but they
+appear to work fine.
+</p>
+<p>
+Compression results:
+</p>
+<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
+<caption></caption>
+<colgroup><col align="left" /><col align="right" /><col align="right" /><col align="left" /><col align="left" />
+</colgroup>
+<thead>
+<tr><th scope="col">Library</th><th scope="col">Orig. size</th><th scope="col">UglifyJS</th><th scope="col">YUI</th><th scope="col">GCL</th></tr>
+</thead>
+<tbody>
+<tr><td>DynarchLIB</td><td>636896</td><td>241441</td><td>246452 (+5011)</td><td>240439 (-1002) (buggy)</td></tr>
+<tr><td>jQuery</td><td>163855</td><td>72006</td><td>79702 (+7696)</td><td>71858 (-148)</td></tr>
+</tbody>
+</table>
+
+
+<p>
+UglifyJS is the fastest to run. On my laptop UglifyJS takes 1.35s for
+DynarchLIB, while YUI takes 2.7s and GCL takes 6.5s.
+</p>
+<p>
+GoogleClosure does a lot of smart ass optimizations. I had to strive really
+hard to get close to it. It should be possible to even beat it, but then
+again, GCL has a gazillion lines of code and runs terribly slow, so I'm not
+sure it worths spending the effort to save a few bytes. Also, GCL doesn't
+cope with <code>eval()</code> or <code>with{}</code> – it just dumps a warning and proceeds to
+mangle names anyway; my DynarchLIB compiled with it is buggy because of
+this.
+</p>
+<p>
+UglifyJS consists of ~1100 lines of code for the tokenizer/parser, and ~1100
+lines for the compressor and code generator. That should make it very
+maintainable and easily extensible, so I would say it has a good place in
+this field and it's bound to become the de-facto standard JS minifier. And
+I shall rule the world. :-) Use it, and <b>spread the word</b>!
+</p>
+</div>
+
+</div>
+
+<div id="outline-container-1_6" class="outline-3">
+<h3 id="sec-1_6"><span class="section-number-3">1.6</span> Bugs? </h3>
+<div class="outline-text-3" id="text-1_6">
+
+
+<p>
+Unfortunately, for the time being there is no automated test suite. But I
+ran the compressor manually on non-trivial code, and then I tested that the
+generated code works as expected. A few hundred times.
+</p>
+<p>
+DynarchLIB was started in times when there was no good JS minifier.
+Therefore I was quite religious about trying to write short code manually,
+and as such DL contains a lot of syntactic hacks<sup><a class="footref" name="fnr.1" href="#fn.1">1</a></sup> such as “foo == bar ? a
+= 10 : b = 20”, though the more readable version would clearly be to use
+“if/else”.
+</p>
+<p>
+Since the parser/compressor runs fine on DL and jQuery, I'm quite confident
+that it's solid enough for production use. If you can identify any bugs,
+I'd love to hear about them (<a href="http://groups.google.com/group/uglifyjs">use the Google Group</a> or email me directly).
+</p>
+</div>
+
+</div>
+
+<div id="outline-container-1_7" class="outline-3">
+<h3 id="sec-1_7"><span class="section-number-3">1.7</span> Links </h3>
+<div class="outline-text-3" id="text-1_7">
+
+
+<ul>
+<li>
+Project at GitHub: <a href="http://github.com/mishoo/UglifyJS">http://github.com/mishoo/UglifyJS</a>
+</li>
+<li>
+Google Group: <a href="http://groups.google.com/group/uglifyjs">http://groups.google.com/group/uglifyjs</a>
+</li>
+<li>
+Common Lisp JS parser: <a href="http://marijn.haverbeke.nl/parse-js/">http://marijn.haverbeke.nl/parse-js/</a>
+</li>
+<li>
+JS-to-Lisp compiler: <a href="http://github.com/marijnh/js">http://github.com/marijnh/js</a>
+</li>
+<li>
+Common Lisp JS uglifier: <a href="http://github.com/mishoo/cl-uglify-js">http://github.com/mishoo/cl-uglify-js</a>
+</li>
+</ul>
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1_8" class="outline-3">
+<h3 id="sec-1_8"><span class="section-number-3">1.8</span> License </h3>
+<div class="outline-text-3" id="text-1_8">
+
+
+<p>
+UglifyJS is released under the BSD license:
+</p>
+
+
+
+<pre class="example">Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+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.
+</pre>
+
+
+
+
+</div>
+</div>
+</div>
+<div id="footnotes">
+<h2 class="footnotes">Footnotes: </h2>
+<div id="text-footnotes">
+<p class="footnote"><sup><a class="footnum" name="fn.1" href="#fnr.1">1</a></sup> I even reported a few bugs and suggested some fixes in the original
+<a href="http://marijn.haverbeke.nl/parse-js/">parse-js</a> library, and Marijn pushed fixes literally in minutes.
+</p>
+</div>
+</div>
+<div id="postamble">
+<p class="author"> Author: Mihai Bazon
+</p>
+<p class="date"> Date: 2011-07-14 12:50:31 EEST</p>
+<p class="creator">HTML generated by org-mode 7.01trans in emacs 23</p>
+</div>
+</div>
+</body>
+</html>
--- /dev/null
+#+TITLE: UglifyJS -- a JavaScript parser/compressor/beautifier
+#+KEYWORDS: javascript, js, parser, compiler, compressor, mangle, minify, minifier
+#+DESCRIPTION: a JavaScript parser/compressor/beautifier in JavaScript
+#+STYLE: <link rel="stylesheet" type="text/css" href="docstyle.css" />
+#+AUTHOR: Mihai Bazon
+#+EMAIL: mihai.bazon@gmail.com
+
+* UglifyJS --- a JavaScript parser/compressor/beautifier
+
+This package implements a general-purpose JavaScript
+parser/compressor/beautifier toolkit. It is developed on [[http://nodejs.org/][NodeJS]], but it
+should work on any JavaScript platform supporting the CommonJS module system
+(and if your platform of choice doesn't support CommonJS, you can easily
+implement it, or discard the =exports.*= lines from UglifyJS sources).
+
+The tokenizer/parser generates an abstract syntax tree from JS code. You
+can then traverse the AST to learn more about the code, or do various
+manipulations on it. This part is implemented in [[../lib/parse-js.js][parse-js.js]] and it's a
+port to JavaScript of the excellent [[http://marijn.haverbeke.nl/parse-js/][parse-js]] Common Lisp library from [[http://marijn.haverbeke.nl/][Marijn
+Haverbeke]].
+
+( See [[http://github.com/mishoo/cl-uglify-js][cl-uglify-js]] if you're looking for the Common Lisp version of
+UglifyJS. )
+
+The second part of this package, implemented in [[../lib/process.js][process.js]], inspects and
+manipulates the AST generated by the parser to provide the following:
+
+- ability to re-generate JavaScript code from the AST. Optionally
+ indented---you can use this if you want to “beautify” a program that has
+ been compressed, so that you can inspect the source. But you can also run
+ our code generator to print out an AST without any whitespace, so you
+ achieve compression as well.
+
+- shorten variable names (usually to single characters). Our mangler will
+ analyze the code and generate proper variable names, depending on scope
+ and usage, and is smart enough to deal with globals defined elsewhere, or
+ with =eval()= calls or =with{}= statements. In short, if =eval()= or
+ =with{}= are used in some scope, then all variables in that scope and any
+ variables in the parent scopes will remain unmangled, and any references
+ to such variables remain unmangled as well.
+
+- various small optimizations that may lead to faster code but certainly
+ lead to smaller code. Where possible, we do the following:
+
+ - foo["bar"] ==> foo.bar
+
+ - remove block brackets ={}=
+
+ - join consecutive var declarations:
+ var a = 10; var b = 20; ==> var a=10,b=20;
+
+ - resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the
+ replacement if the result occupies less bytes; for example 1/3 would
+ translate to 0.333333333333, so in this case we don't replace it.
+
+ - consecutive statements in blocks are merged into a sequence; in many
+ cases, this leaves blocks with a single statement, so then we can remove
+ the block brackets.
+
+ - various optimizations for IF statements:
+
+ - if (foo) bar(); else baz(); ==> foo?bar():baz();
+ - if (!foo) bar(); else baz(); ==> foo?baz():bar();
+ - if (foo) bar(); ==> foo&&bar();
+ - if (!foo) bar(); ==> foo||bar();
+ - if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
+ - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+
+ - remove some unreachable code and warn about it (code that follows a
+ =return=, =throw=, =break= or =continue= statement, except
+ function/variable declarations).
+
+** <<Unsafe transformations>>
+
+UglifyJS tries its best to achieve great compression while leaving the
+semantics of the code intact. In general, if your code logic is broken by
+UglifyJS then it's a bug in UglifyJS and you should report it and I should
+fix it. :-)
+
+However, I opted to include the following potentially unsafe transformations
+as default behavior. Discussion is welcome, if you have ideas of how to
+handle this better, or any objections to these optimizations, please let me
+know.
+
+*** Calls involving the global Array constructor
+
+The following transformations occur:
+
+#+BEGIN_SRC js
+new Array(1, 2, 3, 4) => [1,2,3,4]
+Array(a, b, c) => [a,b,c]
+new Array(5) => Array(5)
+new Array(a) => Array(a)
+#+END_SRC
+
+These are all safe if the Array name isn't redefined. JavaScript does allow
+one to globally redefine Array (and pretty much everything, in fact) but I
+personally don't see why would anyone do that.
+
+UglifyJS does handle the case where Array is redefined locally, or even
+globally but with a =function= or =var= declaration. Therefore, in the
+following cases UglifyJS *doesn't touch* calls or instantiations of Array:
+
+#+BEGIN_SRC js
+// case 1. globally declared variable
+ var Array;
+ new Array(1, 2, 3);
+ Array(a, b);
+
+ // or (can be declared later)
+ new Array(1, 2, 3);
+ var Array;
+
+ // or (can be a function)
+ new Array(1, 2, 3);
+ function Array() { ... }
+
+// case 2. declared in a function
+ (function(){
+ a = new Array(1, 2, 3);
+ b = Array(5, 6);
+ var Array;
+ })();
+
+ // or
+ (function(Array){
+ return Array(5, 6, 7);
+ })();
+
+ // or
+ (function(){
+ return new Array(1, 2, 3, 4);
+ function Array() { ... }
+ })();
+
+ // etc.
+#+END_SRC
+
+** Install (NPM)
+
+UglifyJS is now available through NPM --- =npm install uglify-js= should do
+the job.
+
+** Install latest code from GitHub
+
+#+BEGIN_SRC sh
+## clone the repository
+mkdir -p /where/you/wanna/put/it
+cd /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+## make the module available to Node
+mkdir -p ~/.node_libraries/
+cd ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+## and if you want the CLI script too:
+mkdir -p ~/bin
+cd ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ # (then add ~/bin to your $PATH if it's not there already)
+#+END_SRC
+
+** Usage
+
+There is a command-line tool that exposes the functionality of this library
+for your shell-scripting needs:
+
+#+BEGIN_SRC sh
+uglifyjs [ options... ] [ filename ]
+#+END_SRC
+
+=filename= should be the last argument and should name the file from which
+to read the JavaScript code. If you don't specify it, it will read code
+from STDIN.
+
+Supported options:
+
+- =-b= or =--beautify= --- output indented code; when passed, additional
+ options control the beautifier:
+
+ - =-i N= or =--indent N= --- indentation level (number of spaces)
+
+ - =-q= or =--quote-keys= --- quote keys in literal objects (by default,
+ only keys that cannot be identifier names will be quotes).
+
+- =--ascii= --- pass this argument to encode non-ASCII characters as
+ =\uXXXX= sequences. By default UglifyJS won't bother to do it and will
+ output Unicode characters instead. (the output is always encoded in UTF8,
+ but if you pass this option you'll only get ASCII).
+
+- =-nm= or =--no-mangle= --- don't mangle variable names
+
+- =-ns= or =--no-squeeze= --- don't call =ast_squeeze()= (which does various
+ optimizations that result in smaller, less readable code).
+
+- =-mt= or =--mangle-toplevel= --- mangle names in the toplevel scope too
+ (by default we don't do this).
+
+- =--no-seqs= --- when =ast_squeeze()= is called (thus, unless you pass
+ =--no-squeeze=) it will reduce consecutive statements in blocks into a
+ sequence. For example, "a = 10; b = 20; foo();" will be written as
+ "a=10,b=20,foo();". In various occasions, this allows us to discard the
+ block brackets (since the block becomes a single statement). This is ON
+ by default because it seems safe and saves a few hundred bytes on some
+ libs that I tested it on, but pass =--no-seqs= to disable it.
+
+- =--no-dead-code= --- by default, UglifyJS will remove code that is
+ obviously unreachable (code that follows a =return=, =throw=, =break= or
+ =continue= statement and is not a function/variable declaration). Pass
+ this option to disable this optimization.
+
+- =-nc= or =--no-copyright= --- by default, =uglifyjs= will keep the initial
+ comment tokens in the generated code (assumed to be copyright information
+ etc.). If you pass this it will discard it.
+
+- =-o filename= or =--output filename= --- put the result in =filename=. If
+ this isn't given, the result goes to standard output (or see next one).
+
+- =--overwrite= --- if the code is read from a file (not from STDIN) and you
+ pass =--overwrite= then the output will be written in the same file.
+
+- =--ast= --- pass this if you want to get the Abstract Syntax Tree instead
+ of JavaScript as output. Useful for debugging or learning more about the
+ internals.
+
+- =-v= or =--verbose= --- output some notes on STDERR (for now just how long
+ each operation takes).
+
+- =--extra= --- enable additional optimizations that have not yet been
+ extensively tested. These might, or might not, break your code. If you
+ find a bug using this option, please report a test case.
+
+- =--unsafe= --- enable other additional optimizations that are known to be
+ unsafe in some contrived situations, but could still be generally useful.
+ For now only this:
+
+ - foo.toString() ==> foo+""
+
+- =--max-line-len= (default 32K characters) --- add a newline after around
+ 32K characters. I've seen both FF and Chrome croak when all the code was
+ on a single line of around 670K. Pass --max-line-len 0 to disable this
+ safety feature.
+
+- =--reserved-names= --- some libraries rely on certain names to be used, as
+ pointed out in issue #92 and #81, so this option allow you to exclude such
+ names from the mangler. For example, to keep names =require= and =$super=
+ intact you'd specify --reserved-names "require,$super".
+
+- =--inline-script= -- when you want to include the output literally in an
+ HTML =<script>= tag you can use this option to prevent =</script= from
+ showing up in the output.
+
+*** API
+
+To use the library from JavaScript, you'd do the following (example for
+NodeJS):
+
+#+BEGIN_SRC js
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+var orig_code = "... JS code here";
+var ast = jsp.parse(orig_code); // parse code and get the initial AST
+ast = pro.ast_mangle(ast); // get a new AST with mangled names
+ast = pro.ast_squeeze(ast); // get an AST with compression optimizations
+var final_code = pro.gen_code(ast); // compressed code here
+#+END_SRC
+
+The above performs the full compression that is possible right now. As you
+can see, there are a sequence of steps which you can apply. For example if
+you want compressed output but for some reason you don't want to mangle
+variable names, you would simply skip the line that calls
+=pro.ast_mangle(ast)=.
+
+Some of these functions take optional arguments. Here's a description:
+
+- =jsp.parse(code, strict_semicolons)= -- parses JS code and returns an AST.
+ =strict_semicolons= is optional and defaults to =false=. If you pass
+ =true= then the parser will throw an error when it expects a semicolon and
+ it doesn't find it. For most JS code you don't want that, but it's useful
+ if you want to strictly sanitize your code.
+
+- =pro.ast_mangle(ast, options)= -- generates a new AST containing mangled
+ (compressed) variable and function names. It supports the following
+ options:
+
+ - =toplevel= -- mangle toplevel names (by default we don't touch them).
+ - =except= -- an array of names to exclude from compression.
+
+- =pro.ast_squeeze(ast, options)= -- employs further optimizations designed
+ to reduce the size of the code that =gen_code= would generate from the
+ AST. Returns a new AST. =options= can be a hash; the supported options
+ are:
+
+ - =make_seqs= (default true) which will cause consecutive statements in a
+ block to be merged using the "sequence" (comma) operator
+
+ - =dead_code= (default true) which will remove unreachable code.
+
+- =pro.gen_code(ast, options)= -- generates JS code from the AST. By
+ default it's minified, but using the =options= argument you can get nicely
+ formatted output. =options= is, well, optional :-) and if you pass it it
+ must be an object and supports the following properties (below you can see
+ the default values):
+
+ - =beautify: false= -- pass =true= if you want indented output
+ - =indent_start: 0= (only applies when =beautify= is =true=) -- initial
+ indentation in spaces
+ - =indent_level: 4= (only applies when =beautify= is =true=) --
+ indentation level, in spaces (pass an even number)
+ - =quote_keys: false= -- if you pass =true= it will quote all keys in
+ literal objects
+ - =space_colon: false= (only applies when =beautify= is =true=) -- wether
+ to put a space before the colon in object literals
+ - =ascii_only: false= -- pass =true= if you want to encode non-ASCII
+ characters as =\uXXXX=.
+ - =inline_script: false= -- pass =true= to escape occurrences of
+ =</script= in strings
+
+*** Beautifier shortcoming -- no more comments
+
+The beautifier can be used as a general purpose indentation tool. It's
+useful when you want to make a minified file readable. One limitation,
+though, is that it discards all comments, so you don't really want to use it
+to reformat your code, unless you don't have, or don't care about, comments.
+
+In fact it's not the beautifier who discards comments --- they are dumped at
+the parsing stage, when we build the initial AST. Comments don't really
+make sense in the AST, and while we could add nodes for them, it would be
+inconvenient because we'd have to add special rules to ignore them at all
+the processing stages.
+
+** Compression -- how good is it?
+
+(XXX: this is somewhat outdated. On the jQuery source code we beat Closure
+by 168 bytes (560 after gzip) and by many seconds.)
+
+There are a few popular JS minifiers nowadays -- the two most well known
+being the GoogleClosure (GCL) compiler and the YUI compressor. For some
+reason they are both written in Java. I didn't really hope to beat any of
+them, but finally I did -- UglifyJS compresses better than the YUI
+compressor, and safer than GoogleClosure.
+
+I tested it on two big libraries. [[http://www.dynarchlib.com/][DynarchLIB]] is my own, and it's big enough
+to contain probably all the JavaScript tricks known to mankind. [[http://jquery.com/][jQuery]] is
+definitely the most popular JavaScript library (to some people, it's a
+synonym to JavaScript itself).
+
+I cannot swear that there are no bugs in the generated codes, but they
+appear to work fine.
+
+Compression results:
+
+| Library | Orig. size | UglifyJS | YUI | GCL |
+|------------+------------+----------+----------------+------------------------|
+| DynarchLIB | 636896 | 241441 | 246452 (+5011) | 240439 (-1002) (buggy) |
+| jQuery | 163855 | 72006 | 79702 (+7696) | 71858 (-148) |
+
+UglifyJS is the fastest to run. On my laptop UglifyJS takes 1.35s for
+DynarchLIB, while YUI takes 2.7s and GCL takes 6.5s.
+
+GoogleClosure does a lot of smart ass optimizations. I had to strive really
+hard to get close to it. It should be possible to even beat it, but then
+again, GCL has a gazillion lines of code and runs terribly slow, so I'm not
+sure it worths spending the effort to save a few bytes. Also, GCL doesn't
+cope with =eval()= or =with{}= -- it just dumps a warning and proceeds to
+mangle names anyway; my DynarchLIB compiled with it is buggy because of
+this.
+
+UglifyJS consists of ~1100 lines of code for the tokenizer/parser, and ~1100
+lines for the compressor and code generator. That should make it very
+maintainable and easily extensible, so I would say it has a good place in
+this field and it's bound to become the de-facto standard JS minifier. And
+I shall rule the world. :-) Use it, and *spread the word*!
+
+** Bugs?
+
+Unfortunately, for the time being there is no automated test suite. But I
+ran the compressor manually on non-trivial code, and then I tested that the
+generated code works as expected. A few hundred times.
+
+DynarchLIB was started in times when there was no good JS minifier.
+Therefore I was quite religious about trying to write short code manually,
+and as such DL contains a lot of syntactic hacks[1] such as “foo == bar ? a
+= 10 : b = 20”, though the more readable version would clearly be to use
+“if/else”.
+
+Since the parser/compressor runs fine on DL and jQuery, I'm quite confident
+that it's solid enough for production use. If you can identify any bugs,
+I'd love to hear about them ([[http://groups.google.com/group/uglifyjs][use the Google Group]] or email me directly).
+
+[1] I even reported a few bugs and suggested some fixes in the original
+ [[http://marijn.haverbeke.nl/parse-js/][parse-js]] library, and Marijn pushed fixes literally in minutes.
+
+** Links
+
+- Project at GitHub: [[http://github.com/mishoo/UglifyJS][http://github.com/mishoo/UglifyJS]]
+- Google Group: [[http://groups.google.com/group/uglifyjs][http://groups.google.com/group/uglifyjs]]
+- Common Lisp JS parser: [[http://marijn.haverbeke.nl/parse-js/][http://marijn.haverbeke.nl/parse-js/]]
+- JS-to-Lisp compiler: [[http://github.com/marijnh/js][http://github.com/marijnh/js]]
+- Common Lisp JS uglifier: [[http://github.com/mishoo/cl-uglify-js][http://github.com/mishoo/cl-uglify-js]]
+
+** License
+
+UglifyJS is released under the BSD license:
+
+#+BEGIN_EXAMPLE
+Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+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.
+#+END_EXAMPLE
--- /dev/null
+#! /usr/bin/env node
+// -*- js -*-
+
+global.sys = require(/^v0\.[012]/.test(process.version) ? "sys" : "util");
+var fs = require("fs");
+var uglify = require("uglify-js"), // symlink ~/.node_libraries/uglify-js.js to ../uglify-js.js
+ jsp = uglify.parser,
+ pro = uglify.uglify;
+
+var options = {
+ ast: false,
+ mangle: true,
+ mangle_toplevel: false,
+ squeeze: true,
+ make_seqs: true,
+ dead_code: true,
+ verbose: false,
+ show_copyright: true,
+ out_same_file: false,
+ max_line_length: 32 * 1024,
+ unsafe: false,
+ reserved_names: null,
+ defines: { },
+ codegen_options: {
+ ascii_only: false,
+ beautify: false,
+ indent_level: 4,
+ indent_start: 0,
+ quote_keys: false,
+ space_colon: false,
+ inline_script: false
+ },
+ make: false,
+ output: true // stdout
+};
+
+var args = jsp.slice(process.argv, 2);
+var filename;
+
+out: while (args.length > 0) {
+ var v = args.shift();
+ switch (v) {
+ case "-b":
+ case "--beautify":
+ options.codegen_options.beautify = true;
+ break;
+ case "-i":
+ case "--indent":
+ options.codegen_options.indent_level = args.shift();
+ break;
+ case "-q":
+ case "--quote-keys":
+ options.codegen_options.quote_keys = true;
+ break;
+ case "-mt":
+ case "--mangle-toplevel":
+ options.mangle_toplevel = true;
+ break;
+ case "--no-mangle":
+ case "-nm":
+ options.mangle = false;
+ break;
+ case "--no-squeeze":
+ case "-ns":
+ options.squeeze = false;
+ break;
+ case "--no-seqs":
+ options.make_seqs = false;
+ break;
+ case "--no-dead-code":
+ options.dead_code = false;
+ break;
+ case "--no-copyright":
+ case "-nc":
+ options.show_copyright = false;
+ break;
+ case "-o":
+ case "--output":
+ options.output = args.shift();
+ break;
+ case "--overwrite":
+ options.out_same_file = true;
+ break;
+ case "-v":
+ case "--verbose":
+ options.verbose = true;
+ break;
+ case "--ast":
+ options.ast = true;
+ break;
+ case "--unsafe":
+ options.unsafe = true;
+ break;
+ case "--max-line-len":
+ options.max_line_length = parseInt(args.shift(), 10);
+ break;
+ case "--reserved-names":
+ options.reserved_names = args.shift().split(",");
+ break;
+ case "-d":
+ case "--define":
+ var defarg = args.shift();
+ try {
+ var defsym = function(sym) {
+ // KEYWORDS_ATOM doesn't include NaN or Infinity - should we check
+ // for them too ?? We don't check reserved words and the like as the
+ // define values are only substituted AFTER parsing
+ if (jsp.KEYWORDS_ATOM.hasOwnProperty(sym)) {
+ throw "Don't define values for inbuilt constant '"+sym+"'";
+ }
+ return sym;
+ },
+ defval = function(v) {
+ if (v.match(/^"(.*)"$/) || v.match(/^'(.*)'$/)) {
+ return [ "string", RegExp.$1 ];
+ }
+ else if (!isNaN(parseFloat(v))) {
+ return [ "num", parseFloat(v) ];
+ }
+ else if (v.match(/^[a-z\$_][a-z\$_0-9]*$/i)) {
+ return [ "name", v ];
+ }
+ else if (!v.match(/"/)) {
+ return [ "string", v ];
+ }
+ else if (!v.match(/'/)) {
+ return [ "string", v ];
+ }
+ throw "Can't understand the specified value: "+v;
+ };
+ if (defarg.match(/^([a-z_\$][a-z_\$0-9]*)(=(.*))?$/i)) {
+ var sym = defsym(RegExp.$1),
+ val = RegExp.$2 ? defval(RegExp.$2.substr(1)) : [ 'name', 'true' ];
+ options.defines[sym] = val;
+ }
+ else {
+ throw "The --define option expects SYMBOL[=value]";
+ }
+ } catch(ex) {
+ sys.print("ERROR: In option --define "+defarg+"\n"+ex+"\n");
+ process.exit(1);
+ }
+ break;
+ case "--define-from-module":
+ var defmodarg = args.shift(),
+ defmodule = require(defmodarg),
+ sym,
+ val;
+ for (sym in defmodule) {
+ if (defmodule.hasOwnProperty(sym)) {
+ options.defines[sym] = function(val) {
+ if (typeof val == "string")
+ return [ "string", val ];
+ if (typeof val == "number")
+ return [ "num", val ];
+ if (val === true)
+ return [ 'name', 'true' ];
+ if (val === false)
+ return [ 'name', 'false' ];
+ if (val === null)
+ return [ 'name', 'null' ];
+ if (val === undefined)
+ return [ 'name', 'undefined' ];
+ sys.print("ERROR: In option --define-from-module "+defmodarg+"\n");
+ sys.print("ERROR: Unknown object type for: "+sym+"="+val+"\n");
+ process.exit(1);
+ return null;
+ }(defmodule[sym]);
+ }
+ }
+ break;
+ case "--ascii":
+ options.codegen_options.ascii_only = true;
+ break;
+ case "--make":
+ options.make = true;
+ break;
+ case "--inline-script":
+ options.codegen_options.inline_script = true;
+ break;
+ default:
+ filename = v;
+ break out;
+ }
+}
+
+if (options.verbose) {
+ pro.set_logger(function(msg){
+ sys.debug(msg);
+ });
+}
+
+jsp.set_logger(function(msg){
+ sys.debug(msg);
+});
+
+if (options.make) {
+ options.out_same_file = false; // doesn't make sense in this case
+ var makefile = JSON.parse(fs.readFileSync(filename || "Makefile.uglify.js").toString());
+ output(makefile.files.map(function(file){
+ var code = fs.readFileSync(file.name);
+ if (file.module) {
+ code = "!function(exports, global){global = this;\n" + code + "\n;this." + file.module + " = exports;}({})";
+ }
+ else if (file.hide) {
+ code = "(function(){" + code + "}());";
+ }
+ return squeeze_it(code);
+ }).join("\n"));
+}
+else if (filename) {
+ fs.readFile(filename, "utf8", function(err, text){
+ if (err) throw err;
+ output(squeeze_it(text));
+ });
+}
+else {
+ var stdin = process.openStdin();
+ stdin.setEncoding("utf8");
+ var text = "";
+ stdin.on("data", function(chunk){
+ text += chunk;
+ });
+ stdin.on("end", function() {
+ output(squeeze_it(text));
+ });
+}
+
+function output(text) {
+ var out;
+ if (options.out_same_file && filename)
+ options.output = filename;
+ if (options.output === true) {
+ out = process.stdout;
+ } else {
+ out = fs.createWriteStream(options.output, {
+ flags: "w",
+ encoding: "utf8",
+ mode: 0644
+ });
+ }
+ out.write(text);
+ if (options.output !== true) {
+ out.end();
+ }
+};
+
+// --------- main ends here.
+
+function show_copyright(comments) {
+ var ret = "";
+ for (var i = 0; i < comments.length; ++i) {
+ var c = comments[i];
+ if (c.type == "comment1") {
+ ret += "//" + c.value + "\n";
+ } else {
+ ret += "/*" + c.value + "*/";
+ }
+ }
+ return ret;
+};
+
+function squeeze_it(code) {
+ var result = "";
+ if (options.show_copyright) {
+ var tok = jsp.tokenizer(code), c;
+ c = tok();
+ result += show_copyright(c.comments_before);
+ }
+ try {
+ var ast = time_it("parse", function(){ return jsp.parse(code); });
+ if (options.mangle) ast = time_it("mangle", function(){
+ return pro.ast_mangle(ast, {
+ toplevel: options.mangle_toplevel,
+ defines: options.defines,
+ except: options.reserved_names
+ });
+ });
+ if (options.squeeze) ast = time_it("squeeze", function(){
+ ast = pro.ast_squeeze(ast, {
+ make_seqs : options.make_seqs,
+ dead_code : options.dead_code,
+ keep_comps : !options.unsafe
+ });
+ if (options.unsafe)
+ ast = pro.ast_squeeze_more(ast);
+ return ast;
+ });
+ if (options.ast)
+ return sys.inspect(ast, null, null);
+ result += time_it("generate", function(){ return pro.gen_code(ast, options.codegen_options) });
+ if (!options.codegen_options.beautify && options.max_line_length) {
+ result = time_it("split", function(){ return pro.split_lines(result, options.max_line_length) });
+ }
+ return result;
+ } catch(ex) {
+ sys.debug(ex.stack);
+ sys.debug(sys.inspect(ex));
+ sys.debug(JSON.stringify(ex));
+ }
+};
+
+function time_it(name, cont) {
+ if (!options.verbose)
+ return cont();
+ var t1 = new Date().getTime();
+ try { return cont(); }
+ finally { sys.debug("// " + name + ": " + ((new Date().getTime() - t1) / 1000).toFixed(3) + " sec."); }
+};
--- /dev/null
+html { font-family: "Lucida Grande","Trebuchet MS",sans-serif; font-size: 12pt; }
+body { max-width: 60em; }
+.title { text-align: center; }
+.todo { color: red; }
+.done { color: green; }
+.tag { background-color:lightblue; font-weight:normal }
+.target { }
+.timestamp { color: grey }
+.timestamp-kwd { color: CadetBlue }
+p.verse { margin-left: 3% }
+pre {
+ border: 1pt solid #AEBDCC;
+ background-color: #F3F5F7;
+ padding: 5pt;
+ font-family: monospace;
+ font-size: 90%;
+ overflow:auto;
+}
+pre.src {
+ background-color: #eee; color: #112; border: 1px solid #000;
+}
+table { border-collapse: collapse; }
+td, th { vertical-align: top; }
+dt { font-weight: bold; }
+div.figure { padding: 0.5em; }
+div.figure p { text-align: center; }
+.linenr { font-size:smaller }
+.code-highlighted {background-color:#ffff00;}
+.org-info-js_info-navigation { border-style:none; }
+#org-info-js_console-label { font-size:10px; font-weight:bold;
+ white-space:nowrap; }
+.org-info-js_search-highlight {background-color:#ffff00; color:#000000;
+ font-weight:bold; }
+
+sup {
+ vertical-align: baseline;
+ position: relative;
+ top: -0.5em;
+ font-size: 80%;
+}
+
+sup a:link, sup a:visited {
+ text-decoration: none;
+ color: #c00;
+}
+
+sup a:before { content: "["; color: #999; }
+sup a:after { content: "]"; color: #999; }
+
+h1.title { border-bottom: 4px solid #000; padding-bottom: 5px; margin-bottom: 2em; }
+
+#postamble {
+ color: #777;
+ font-size: 90%;
+ padding-top: 1em; padding-bottom: 1em; border-top: 1px solid #999;
+ margin-top: 2em;
+ padding-left: 2em;
+ padding-right: 2em;
+ text-align: right;
+}
+
+#postamble p { margin: 0; }
+
+#footnotes { border-top: 1px solid #000; }
+
+h1 { font-size: 200% }
+h2 { font-size: 175% }
+h3 { font-size: 150% }
+h4 { font-size: 125% }
+
+h1, h2, h3, h4 { font-family: "Bookman",Georgia,"Times New Roman",serif; font-weight: normal; }
+
+@media print {
+ html { font-size: 11pt; }
+}
--- /dev/null
+/***********************************************************************
+
+ A JavaScript tokenizer / parser / beautifier / compressor.
+
+ This version is suitable for Node.js. With minimal changes (the
+ exports stuff) it should work on any JS platform.
+
+ This file contains the tokenizer/parser. It is a port to JavaScript
+ of parse-js [1], a JavaScript parser library written in Common Lisp
+ by Marijn Haverbeke. Thank you Marijn!
+
+ [1] http://marijn.haverbeke.nl/parse-js/
+
+ Exported functions:
+
+ - tokenizer(code) -- returns a function. Call the returned
+ function to fetch the next token.
+
+ - parse(code) -- returns an AST of the given JavaScript code.
+
+ -------------------------------- (C) ---------------------------------
+
+ Author: Mihai Bazon
+ <mihai.bazon@gmail.com>
+ http://mihai.bazon.net/blog
+
+ Distributed under the BSD license:
+
+ Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+ Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+ 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.
+
+ ***********************************************************************/
+
+/* -----[ Tokenizer (constants) ]----- */
+
+var KEYWORDS = array_to_hash([
+ "break",
+ "case",
+ "catch",
+ "const",
+ "continue",
+ "default",
+ "delete",
+ "do",
+ "else",
+ "finally",
+ "for",
+ "function",
+ "if",
+ "in",
+ "instanceof",
+ "new",
+ "return",
+ "switch",
+ "throw",
+ "try",
+ "typeof",
+ "var",
+ "void",
+ "while",
+ "with"
+]);
+
+var RESERVED_WORDS = array_to_hash([
+ "abstract",
+ "boolean",
+ "byte",
+ "char",
+ "class",
+ "debugger",
+ "double",
+ "enum",
+ "export",
+ "extends",
+ "final",
+ "float",
+ "goto",
+ "implements",
+ "import",
+ "int",
+ "interface",
+ "long",
+ "native",
+ "package",
+ "private",
+ "protected",
+ "public",
+ "short",
+ "static",
+ "super",
+ "synchronized",
+ "throws",
+ "transient",
+ "volatile"
+]);
+
+var KEYWORDS_BEFORE_EXPRESSION = array_to_hash([
+ "return",
+ "new",
+ "delete",
+ "throw",
+ "else",
+ "case"
+]);
+
+var KEYWORDS_ATOM = array_to_hash([
+ "false",
+ "null",
+ "true",
+ "undefined"
+]);
+
+var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^"));
+
+var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
+var RE_OCT_NUMBER = /^0[0-7]+$/;
+var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
+
+var OPERATORS = array_to_hash([
+ "in",
+ "instanceof",
+ "typeof",
+ "new",
+ "void",
+ "delete",
+ "++",
+ "--",
+ "+",
+ "-",
+ "!",
+ "~",
+ "&",
+ "|",
+ "^",
+ "*",
+ "/",
+ "%",
+ ">>",
+ "<<",
+ ">>>",
+ "<",
+ ">",
+ "<=",
+ ">=",
+ "==",
+ "===",
+ "!=",
+ "!==",
+ "?",
+ "=",
+ "+=",
+ "-=",
+ "/=",
+ "*=",
+ "%=",
+ ">>=",
+ "<<=",
+ ">>>=",
+ "|=",
+ "^=",
+ "&=",
+ "&&",
+ "||"
+]);
+
+var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\v\u200b"));
+
+var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{}(,.;:"));
+
+var PUNC_CHARS = array_to_hash(characters("[]{}(),;:"));
+
+var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy"));
+
+/* -----[ Tokenizer ]----- */
+
+// regexps adapted from http://xregexp.com/plugins/#unicode
+var UNICODE = {
+ letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+ non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
+ space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
+ connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
+};
+
+function is_letter(ch) {
+ return UNICODE.letter.test(ch);
+};
+
+function is_digit(ch) {
+ ch = ch.charCodeAt(0);
+ return ch >= 48 && ch <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9
+};
+
+function is_alphanumeric_char(ch) {
+ return is_digit(ch) || is_letter(ch);
+};
+
+function is_unicode_combining_mark(ch) {
+ return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
+};
+
+function is_unicode_connector_punctuation(ch) {
+ return UNICODE.connector_punctuation.test(ch);
+};
+
+function is_identifier_start(ch) {
+ return ch == "$" || ch == "_" || is_letter(ch);
+};
+
+function is_identifier_char(ch) {
+ return is_identifier_start(ch)
+ || is_unicode_combining_mark(ch)
+ || is_digit(ch)
+ || is_unicode_connector_punctuation(ch)
+ || ch == "\u200c" // zero-width non-joiner <ZWNJ>
+ || ch == "\u200d" // zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
+ ;
+};
+
+function parse_js_number(num) {
+ if (RE_HEX_NUMBER.test(num)) {
+ return parseInt(num.substr(2), 16);
+ } else if (RE_OCT_NUMBER.test(num)) {
+ return parseInt(num.substr(1), 8);
+ } else if (RE_DEC_NUMBER.test(num)) {
+ return parseFloat(num);
+ }
+};
+
+function JS_Parse_Error(message, line, col, pos) {
+ this.message = message;
+ this.line = line;
+ this.col = col;
+ this.pos = pos;
+ try {
+ ({})();
+ } catch(ex) {
+ this.stack = ex.stack;
+ };
+};
+
+JS_Parse_Error.prototype.toString = function() {
+ return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
+};
+
+function js_error(message, line, col, pos) {
+ throw new JS_Parse_Error(message, line, col, pos);
+};
+
+function is_token(token, type, val) {
+ return token.type == type && (val == null || token.value == val);
+};
+
+var EX_EOF = {};
+
+function tokenizer($TEXT) {
+
+ var S = {
+ text : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, ''),
+ pos : 0,
+ tokpos : 0,
+ line : 0,
+ tokline : 0,
+ col : 0,
+ tokcol : 0,
+ newline_before : false,
+ regex_allowed : false,
+ comments_before : []
+ };
+
+ function peek() { return S.text.charAt(S.pos); };
+
+ function next(signal_eof) {
+ var ch = S.text.charAt(S.pos++);
+ if (signal_eof && !ch)
+ throw EX_EOF;
+ if (ch == "\n") {
+ S.newline_before = true;
+ ++S.line;
+ S.col = 0;
+ } else {
+ ++S.col;
+ }
+ return ch;
+ };
+
+ function eof() {
+ return !S.peek();
+ };
+
+ function find(what, signal_eof) {
+ var pos = S.text.indexOf(what, S.pos);
+ if (signal_eof && pos == -1) throw EX_EOF;
+ return pos;
+ };
+
+ function start_token() {
+ S.tokline = S.line;
+ S.tokcol = S.col;
+ S.tokpos = S.pos;
+ };
+
+ function token(type, value, is_comment) {
+ S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) ||
+ (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) ||
+ (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value)));
+ var ret = {
+ type : type,
+ value : value,
+ line : S.tokline,
+ col : S.tokcol,
+ pos : S.tokpos,
+ nlb : S.newline_before
+ };
+ if (!is_comment) {
+ ret.comments_before = S.comments_before;
+ S.comments_before = [];
+ }
+ S.newline_before = false;
+ return ret;
+ };
+
+ function skip_whitespace() {
+ while (HOP(WHITESPACE_CHARS, peek()))
+ next();
+ };
+
+ function read_while(pred) {
+ var ret = "", ch = peek(), i = 0;
+ while (ch && pred(ch, i++)) {
+ ret += next();
+ ch = peek();
+ }
+ return ret;
+ };
+
+ function parse_error(err) {
+ js_error(err, S.tokline, S.tokcol, S.tokpos);
+ };
+
+ function read_num(prefix) {
+ var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
+ var num = read_while(function(ch, i){
+ if (ch == "x" || ch == "X") {
+ if (has_x) return false;
+ return has_x = true;
+ }
+ if (!has_x && (ch == "E" || ch == "e")) {
+ if (has_e) return false;
+ return has_e = after_e = true;
+ }
+ if (ch == "-") {
+ if (after_e || (i == 0 && !prefix)) return true;
+ return false;
+ }
+ if (ch == "+") return after_e;
+ after_e = false;
+ if (ch == ".") {
+ if (!has_dot && !has_x)
+ return has_dot = true;
+ return false;
+ }
+ return is_alphanumeric_char(ch);
+ });
+ if (prefix)
+ num = prefix + num;
+ var valid = parse_js_number(num);
+ if (!isNaN(valid)) {
+ return token("num", valid);
+ } else {
+ parse_error("Invalid syntax: " + num);
+ }
+ };
+
+ function read_escaped_char() {
+ var ch = next(true);
+ switch (ch) {
+ case "n" : return "\n";
+ case "r" : return "\r";
+ case "t" : return "\t";
+ case "b" : return "\b";
+ case "v" : return "\v";
+ case "f" : return "\f";
+ case "0" : return "\0";
+ case "x" : return String.fromCharCode(hex_bytes(2));
+ case "u" : return String.fromCharCode(hex_bytes(4));
+ default : return ch;
+ }
+ };
+
+ function hex_bytes(n) {
+ var num = 0;
+ for (; n > 0; --n) {
+ var digit = parseInt(next(true), 16);
+ if (isNaN(digit))
+ parse_error("Invalid hex-character pattern in string");
+ num = (num << 4) | digit;
+ }
+ return num;
+ };
+
+ function read_string() {
+ return with_eof_error("Unterminated string constant", function(){
+ var quote = next(), ret = "";
+ for (;;) {
+ var ch = next(true);
+ if (ch == "\\") {
+ // read OctalEscapeSequence (XXX: deprecated if "strict mode")
+ // https://github.com/mishoo/UglifyJS/issues/178
+ var octal_len = 0, first = null;
+ ch = read_while(function(ch){
+ if (ch >= "0" && ch <= "7") {
+ if (!first) {
+ first = ch;
+ return ++octal_len;
+ }
+ else if (first <= "3" && octal_len <= 2) return ++octal_len;
+ else if (first >= "4" && octal_len <= 1) return ++octal_len;
+ }
+ return false;
+ });
+ if (octal_len > 0) ch = String.fromCharCode(parseInt(ch, 8));
+ else ch = read_escaped_char();
+ }
+ else if (ch == quote) break;
+ ret += ch;
+ }
+ return token("string", ret);
+ });
+ };
+
+ function read_line_comment() {
+ next();
+ var i = find("\n"), ret;
+ if (i == -1) {
+ ret = S.text.substr(S.pos);
+ S.pos = S.text.length;
+ } else {
+ ret = S.text.substring(S.pos, i);
+ S.pos = i;
+ }
+ return token("comment1", ret, true);
+ };
+
+ function read_multiline_comment() {
+ next();
+ return with_eof_error("Unterminated multiline comment", function(){
+ var i = find("*/", true),
+ text = S.text.substring(S.pos, i),
+ tok = token("comment2", text, true);
+ S.pos = i + 2;
+ S.line += text.split("\n").length - 1;
+ S.newline_before = text.indexOf("\n") >= 0;
+
+ // https://github.com/mishoo/UglifyJS/issues/#issue/100
+ if (/^@cc_on/i.test(text)) {
+ warn("WARNING: at line " + S.line);
+ warn("*** Found \"conditional comment\": " + text);
+ warn("*** UglifyJS DISCARDS ALL COMMENTS. This means your code might no longer work properly in Internet Explorer.");
+ }
+
+ return tok;
+ });
+ };
+
+ function read_name() {
+ var backslash = false, name = "", ch;
+ while ((ch = peek()) != null) {
+ if (!backslash) {
+ if (ch == "\\") backslash = true, next();
+ else if (is_identifier_char(ch)) name += next();
+ else break;
+ }
+ else {
+ if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX");
+ ch = read_escaped_char();
+ if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
+ name += ch;
+ backslash = false;
+ }
+ }
+ return name;
+ };
+
+ function read_regexp() {
+ return with_eof_error("Unterminated regular expression", function(){
+ var prev_backslash = false, regexp = "", ch, in_class = false;
+ while ((ch = next(true))) if (prev_backslash) {
+ regexp += "\\" + ch;
+ prev_backslash = false;
+ } else if (ch == "[") {
+ in_class = true;
+ regexp += ch;
+ } else if (ch == "]" && in_class) {
+ in_class = false;
+ regexp += ch;
+ } else if (ch == "/" && !in_class) {
+ break;
+ } else if (ch == "\\") {
+ prev_backslash = true;
+ } else {
+ regexp += ch;
+ }
+ var mods = read_name();
+ return token("regexp", [ regexp, mods ]);
+ });
+ };
+
+ function read_operator(prefix) {
+ function grow(op) {
+ if (!peek()) return op;
+ var bigger = op + peek();
+ if (HOP(OPERATORS, bigger)) {
+ next();
+ return grow(bigger);
+ } else {
+ return op;
+ }
+ };
+ return token("operator", grow(prefix || next()));
+ };
+
+ function handle_slash() {
+ next();
+ var regex_allowed = S.regex_allowed;
+ switch (peek()) {
+ case "/":
+ S.comments_before.push(read_line_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ case "*":
+ S.comments_before.push(read_multiline_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ }
+ return S.regex_allowed ? read_regexp() : read_operator("/");
+ };
+
+ function handle_dot() {
+ next();
+ return is_digit(peek())
+ ? read_num(".")
+ : token("punc", ".");
+ };
+
+ function read_word() {
+ var word = read_name();
+ return !HOP(KEYWORDS, word)
+ ? token("name", word)
+ : HOP(OPERATORS, word)
+ ? token("operator", word)
+ : HOP(KEYWORDS_ATOM, word)
+ ? token("atom", word)
+ : token("keyword", word);
+ };
+
+ function with_eof_error(eof_error, cont) {
+ try {
+ return cont();
+ } catch(ex) {
+ if (ex === EX_EOF) parse_error(eof_error);
+ else throw ex;
+ }
+ };
+
+ function next_token(force_regexp) {
+ if (force_regexp)
+ return read_regexp();
+ skip_whitespace();
+ start_token();
+ var ch = peek();
+ if (!ch) return token("eof");
+ if (is_digit(ch)) return read_num();
+ if (ch == '"' || ch == "'") return read_string();
+ if (HOP(PUNC_CHARS, ch)) return token("punc", next());
+ if (ch == ".") return handle_dot();
+ if (ch == "/") return handle_slash();
+ if (HOP(OPERATOR_CHARS, ch)) return read_operator();
+ if (ch == "\\" || is_identifier_start(ch)) return read_word();
+ parse_error("Unexpected character '" + ch + "'");
+ };
+
+ next_token.context = function(nc) {
+ if (nc) S = nc;
+ return S;
+ };
+
+ return next_token;
+
+};
+
+/* -----[ Parser (constants) ]----- */
+
+var UNARY_PREFIX = array_to_hash([
+ "typeof",
+ "void",
+ "delete",
+ "--",
+ "++",
+ "!",
+ "~",
+ "-",
+ "+"
+]);
+
+var UNARY_POSTFIX = array_to_hash([ "--", "++" ]);
+
+var ASSIGNMENT = (function(a, ret, i){
+ while (i < a.length) {
+ ret[a[i]] = a[i].substr(0, a[i].length - 1);
+ i++;
+ }
+ return ret;
+})(
+ ["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="],
+ { "=": true },
+ 0
+);
+
+var PRECEDENCE = (function(a, ret){
+ for (var i = 0, n = 1; i < a.length; ++i, ++n) {
+ var b = a[i];
+ for (var j = 0; j < b.length; ++j) {
+ ret[b[j]] = n;
+ }
+ }
+ return ret;
+})(
+ [
+ ["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"]
+ ],
+ {}
+);
+
+var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
+
+var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+
+/* -----[ Parser ]----- */
+
+function NodeWithToken(str, start, end) {
+ this.name = str;
+ this.start = start;
+ this.end = end;
+};
+
+NodeWithToken.prototype.toString = function() { return this.name; };
+
+function parse($TEXT, exigent_mode, embed_tokens) {
+
+ var S = {
+ input : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
+ token : null,
+ prev : null,
+ peeked : null,
+ in_function : 0,
+ in_loop : 0,
+ labels : []
+ };
+
+ S.token = next();
+
+ function is(type, value) {
+ return is_token(S.token, type, value);
+ };
+
+ function peek() { return S.peeked || (S.peeked = S.input()); };
+
+ function next() {
+ S.prev = S.token;
+ if (S.peeked) {
+ S.token = S.peeked;
+ S.peeked = null;
+ } else {
+ S.token = S.input();
+ }
+ return S.token;
+ };
+
+ function prev() {
+ return S.prev;
+ };
+
+ function croak(msg, line, col, pos) {
+ var ctx = S.input.context();
+ js_error(msg,
+ line != null ? line : ctx.tokline,
+ col != null ? col : ctx.tokcol,
+ pos != null ? pos : ctx.tokpos);
+ };
+
+ function token_error(token, msg) {
+ croak(msg, token.line, token.col);
+ };
+
+ function unexpected(token) {
+ if (token == null)
+ token = S.token;
+ token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
+ };
+
+ function expect_token(type, val) {
+ if (is(type, val)) {
+ return next();
+ }
+ token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
+ };
+
+ function expect(punc) { return expect_token("punc", punc); };
+
+ function can_insert_semicolon() {
+ return !exigent_mode && (
+ S.token.nlb || is("eof") || is("punc", "}")
+ );
+ };
+
+ function semicolon() {
+ if (is("punc", ";")) next();
+ else if (!can_insert_semicolon()) unexpected();
+ };
+
+ function as() {
+ return slice(arguments);
+ };
+
+ function parenthesised() {
+ expect("(");
+ var ex = expression();
+ expect(")");
+ return ex;
+ };
+
+ function add_tokens(str, start, end) {
+ return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
+ };
+
+ function maybe_embed_tokens(parser) {
+ if (embed_tokens) return function() {
+ var start = S.token;
+ var ast = parser.apply(this, arguments);
+ ast[0] = add_tokens(ast[0], start, prev());
+ return ast;
+ };
+ else return parser;
+ };
+
+ var statement = maybe_embed_tokens(function() {
+ if (is("operator", "/")) {
+ S.peeked = null;
+ S.token = S.input(true); // force regexp
+ }
+ switch (S.token.type) {
+ case "num":
+ case "string":
+ case "regexp":
+ case "operator":
+ case "atom":
+ return simple_statement();
+
+ case "name":
+ return is_token(peek(), "punc", ":")
+ ? labeled_statement(prog1(S.token.value, next, next))
+ : simple_statement();
+
+ case "punc":
+ switch (S.token.value) {
+ case "{":
+ return as("block", block_());
+ case "[":
+ case "(":
+ return simple_statement();
+ case ";":
+ next();
+ return as("block");
+ default:
+ unexpected();
+ }
+
+ case "keyword":
+ switch (prog1(S.token.value, next)) {
+ case "break":
+ return break_cont("break");
+
+ case "continue":
+ return break_cont("continue");
+
+ case "debugger":
+ semicolon();
+ return as("debugger");
+
+ case "do":
+ return (function(body){
+ expect_token("keyword", "while");
+ return as("do", prog1(parenthesised, semicolon), body);
+ })(in_loop(statement));
+
+ case "for":
+ return for_();
+
+ case "function":
+ return function_(true);
+
+ case "if":
+ return if_();
+
+ case "return":
+ if (S.in_function == 0)
+ croak("'return' outside of function");
+ return as("return",
+ is("punc", ";")
+ ? (next(), null)
+ : can_insert_semicolon()
+ ? null
+ : prog1(expression, semicolon));
+
+ case "switch":
+ return as("switch", parenthesised(), switch_block_());
+
+ case "throw":
+ return as("throw", prog1(expression, semicolon));
+
+ case "try":
+ return try_();
+
+ case "var":
+ return prog1(var_, semicolon);
+
+ case "const":
+ return prog1(const_, semicolon);
+
+ case "while":
+ return as("while", parenthesised(), in_loop(statement));
+
+ case "with":
+ return as("with", parenthesised(), statement());
+
+ default:
+ unexpected();
+ }
+ }
+ });
+
+ function labeled_statement(label) {
+ S.labels.push(label);
+ var start = S.token, stat = statement();
+ if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
+ unexpected(start);
+ S.labels.pop();
+ return as("label", label, stat);
+ };
+
+ function simple_statement() {
+ return as("stat", prog1(expression, semicolon));
+ };
+
+ function break_cont(type) {
+ var name;
+ if (!can_insert_semicolon()) {
+ name = is("name") ? S.token.value : null;
+ }
+ if (name != null) {
+ next();
+ if (!member(name, S.labels))
+ croak("Label " + name + " without matching loop or statement");
+ }
+ else if (S.in_loop == 0)
+ croak(type + " not inside a loop or switch");
+ semicolon();
+ return as(type, name);
+ };
+
+ function for_() {
+ expect("(");
+ var init = null;
+ if (!is("punc", ";")) {
+ init = is("keyword", "var")
+ ? (next(), var_(true))
+ : expression(true, true);
+ if (is("operator", "in"))
+ return for_in(init);
+ }
+ return regular_for(init);
+ };
+
+ function regular_for(init) {
+ expect(";");
+ var test = is("punc", ";") ? null : expression();
+ expect(";");
+ var step = is("punc", ")") ? null : expression();
+ expect(")");
+ return as("for", init, test, step, in_loop(statement));
+ };
+
+ function for_in(init) {
+ var lhs = init[0] == "var" ? as("name", init[1][0]) : init;
+ next();
+ var obj = expression();
+ expect(")");
+ return as("for-in", init, lhs, obj, in_loop(statement));
+ };
+
+ var function_ = maybe_embed_tokens(function(in_statement) {
+ var name = is("name") ? prog1(S.token.value, next) : null;
+ if (in_statement && !name)
+ unexpected();
+ expect("(");
+ return as(in_statement ? "defun" : "function",
+ name,
+ // arguments
+ (function(first, a){
+ while (!is("punc", ")")) {
+ if (first) first = false; else expect(",");
+ if (!is("name")) unexpected();
+ a.push(S.token.value);
+ next();
+ }
+ next();
+ return a;
+ })(true, []),
+ // body
+ (function(){
+ ++S.in_function;
+ var loop = S.in_loop;
+ S.in_loop = 0;
+ var a = block_();
+ --S.in_function;
+ S.in_loop = loop;
+ return a;
+ })());
+ });
+
+ function if_() {
+ var cond = parenthesised(), body = statement(), belse;
+ if (is("keyword", "else")) {
+ next();
+ belse = statement();
+ }
+ return as("if", cond, body, belse);
+ };
+
+ function block_() {
+ expect("{");
+ var a = [];
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ a.push(statement());
+ }
+ next();
+ return a;
+ };
+
+ var switch_block_ = curry(in_loop, function(){
+ expect("{");
+ var a = [], cur = null;
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ if (is("keyword", "case")) {
+ next();
+ cur = [];
+ a.push([ expression(), cur ]);
+ expect(":");
+ }
+ else if (is("keyword", "default")) {
+ next();
+ expect(":");
+ cur = [];
+ a.push([ null, cur ]);
+ }
+ else {
+ if (!cur) unexpected();
+ cur.push(statement());
+ }
+ }
+ next();
+ return a;
+ });
+
+ function try_() {
+ var body = block_(), bcatch, bfinally;
+ if (is("keyword", "catch")) {
+ next();
+ expect("(");
+ if (!is("name"))
+ croak("Name expected");
+ var name = S.token.value;
+ next();
+ expect(")");
+ bcatch = [ name, block_() ];
+ }
+ if (is("keyword", "finally")) {
+ next();
+ bfinally = block_();
+ }
+ if (!bcatch && !bfinally)
+ croak("Missing catch/finally blocks");
+ return as("try", body, bcatch, bfinally);
+ };
+
+ function vardefs(no_in) {
+ var a = [];
+ for (;;) {
+ if (!is("name"))
+ unexpected();
+ var name = S.token.value;
+ next();
+ if (is("operator", "=")) {
+ next();
+ a.push([ name, expression(false, no_in) ]);
+ } else {
+ a.push([ name ]);
+ }
+ if (!is("punc", ","))
+ break;
+ next();
+ }
+ return a;
+ };
+
+ function var_(no_in) {
+ return as("var", vardefs(no_in));
+ };
+
+ function const_() {
+ return as("const", vardefs());
+ };
+
+ function new_() {
+ var newexp = expr_atom(false), args;
+ if (is("punc", "(")) {
+ next();
+ args = expr_list(")");
+ } else {
+ args = [];
+ }
+ return subscripts(as("new", newexp, args), true);
+ };
+
+ var expr_atom = maybe_embed_tokens(function(allow_calls) {
+ if (is("operator", "new")) {
+ next();
+ return new_();
+ }
+ if (is("punc")) {
+ switch (S.token.value) {
+ case "(":
+ next();
+ return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
+ case "[":
+ next();
+ return subscripts(array_(), allow_calls);
+ case "{":
+ next();
+ return subscripts(object_(), allow_calls);
+ }
+ unexpected();
+ }
+ if (is("keyword", "function")) {
+ next();
+ return subscripts(function_(false), allow_calls);
+ }
+ if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
+ var atom = S.token.type == "regexp"
+ ? as("regexp", S.token.value[0], S.token.value[1])
+ : as(S.token.type, S.token.value);
+ return subscripts(prog1(atom, next), allow_calls);
+ }
+ unexpected();
+ });
+
+ function expr_list(closing, allow_trailing_comma, allow_empty) {
+ var first = true, a = [];
+ while (!is("punc", closing)) {
+ if (first) first = false; else expect(",");
+ if (allow_trailing_comma && is("punc", closing)) break;
+ if (is("punc", ",") && allow_empty) {
+ a.push([ "atom", "undefined" ]);
+ } else {
+ a.push(expression(false));
+ }
+ }
+ next();
+ return a;
+ };
+
+ function array_() {
+ return as("array", expr_list("]", !exigent_mode, true));
+ };
+
+ function object_() {
+ var first = true, a = [];
+ while (!is("punc", "}")) {
+ if (first) first = false; else expect(",");
+ if (!exigent_mode && is("punc", "}"))
+ // allow trailing comma
+ break;
+ var type = S.token.type;
+ var name = as_property_name();
+ if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) {
+ a.push([ as_name(), function_(false), name ]);
+ } else {
+ expect(":");
+ a.push([ name, expression(false) ]);
+ }
+ }
+ next();
+ return as("object", a);
+ };
+
+ function as_property_name() {
+ switch (S.token.type) {
+ case "num":
+ case "string":
+ return prog1(S.token.value, next);
+ }
+ return as_name();
+ };
+
+ function as_name() {
+ switch (S.token.type) {
+ case "name":
+ case "operator":
+ case "keyword":
+ case "atom":
+ return prog1(S.token.value, next);
+ default:
+ unexpected();
+ }
+ };
+
+ function subscripts(expr, allow_calls) {
+ if (is("punc", ".")) {
+ next();
+ return subscripts(as("dot", expr, as_name()), allow_calls);
+ }
+ if (is("punc", "[")) {
+ next();
+ return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
+ }
+ if (allow_calls && is("punc", "(")) {
+ next();
+ return subscripts(as("call", expr, expr_list(")")), true);
+ }
+ return expr;
+ };
+
+ function maybe_unary(allow_calls) {
+ if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
+ return make_unary("unary-prefix",
+ prog1(S.token.value, next),
+ maybe_unary(allow_calls));
+ }
+ var val = expr_atom(allow_calls);
+ while (is("operator") && HOP(UNARY_POSTFIX, S.token.value) && !S.token.nlb) {
+ val = make_unary("unary-postfix", S.token.value, val);
+ next();
+ }
+ return val;
+ };
+
+ function make_unary(tag, op, expr) {
+ if ((op == "++" || op == "--") && !is_assignable(expr))
+ croak("Invalid use of " + op + " operator");
+ return as(tag, op, expr);
+ };
+
+ function expr_op(left, min_prec, no_in) {
+ var op = is("operator") ? S.token.value : null;
+ if (op && op == "in" && no_in) op = null;
+ var prec = op != null ? PRECEDENCE[op] : null;
+ if (prec != null && prec > min_prec) {
+ next();
+ var right = expr_op(maybe_unary(true), prec, no_in);
+ return expr_op(as("binary", op, left, right), min_prec, no_in);
+ }
+ return left;
+ };
+
+ function expr_ops(no_in) {
+ return expr_op(maybe_unary(true), 0, no_in);
+ };
+
+ function maybe_conditional(no_in) {
+ var expr = expr_ops(no_in);
+ if (is("operator", "?")) {
+ next();
+ var yes = expression(false);
+ expect(":");
+ return as("conditional", expr, yes, expression(false, no_in));
+ }
+ return expr;
+ };
+
+ function is_assignable(expr) {
+ if (!exigent_mode) return true;
+ switch (expr[0]) {
+ case "dot":
+ case "sub":
+ case "new":
+ case "call":
+ return true;
+ case "name":
+ return expr[1] != "this";
+ }
+ };
+
+ function maybe_assign(no_in) {
+ var left = maybe_conditional(no_in), val = S.token.value;
+ if (is("operator") && HOP(ASSIGNMENT, val)) {
+ if (is_assignable(left)) {
+ next();
+ return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in));
+ }
+ croak("Invalid assignment");
+ }
+ return left;
+ };
+
+ var expression = maybe_embed_tokens(function(commas, no_in) {
+ if (arguments.length == 0)
+ commas = true;
+ var expr = maybe_assign(no_in);
+ if (commas && is("punc", ",")) {
+ next();
+ return as("seq", expr, expression(true, no_in));
+ }
+ return expr;
+ });
+
+ function in_loop(cont) {
+ try {
+ ++S.in_loop;
+ return cont();
+ } finally {
+ --S.in_loop;
+ }
+ };
+
+ return as("toplevel", (function(a){
+ while (!is("eof"))
+ a.push(statement());
+ return a;
+ })([]));
+
+};
+
+/* -----[ Utilities ]----- */
+
+function curry(f) {
+ var args = slice(arguments, 1);
+ return function() { return f.apply(this, args.concat(slice(arguments))); };
+};
+
+function prog1(ret) {
+ if (ret instanceof Function)
+ ret = ret();
+ for (var i = 1, n = arguments.length; --n > 0; ++i)
+ arguments[i]();
+ return ret;
+};
+
+function array_to_hash(a) {
+ var ret = {};
+ for (var i = 0; i < a.length; ++i)
+ ret[a[i]] = true;
+ return ret;
+};
+
+function slice(a, start) {
+ return Array.prototype.slice.call(a, start == null ? 0 : start);
+};
+
+function characters(str) {
+ return str.split("");
+};
+
+function member(name, array) {
+ for (var i = array.length; --i >= 0;)
+ if (array[i] === name)
+ return true;
+ return false;
+};
+
+function HOP(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+var warn = function() {};
+
+/* -----[ Exports ]----- */
+
+exports.tokenizer = tokenizer;
+exports.parse = parse;
+exports.slice = slice;
+exports.curry = curry;
+exports.member = member;
+exports.array_to_hash = array_to_hash;
+exports.PRECEDENCE = PRECEDENCE;
+exports.KEYWORDS_ATOM = KEYWORDS_ATOM;
+exports.RESERVED_WORDS = RESERVED_WORDS;
+exports.KEYWORDS = KEYWORDS;
+exports.ATOMIC_START_TOKEN = ATOMIC_START_TOKEN;
+exports.OPERATORS = OPERATORS;
+exports.is_alphanumeric_char = is_alphanumeric_char;
+exports.set_logger = function(logger) {
+ warn = logger;
+};
--- /dev/null
+/***********************************************************************
+
+ A JavaScript tokenizer / parser / beautifier / compressor.
+
+ This version is suitable for Node.js. With minimal changes (the
+ exports stuff) it should work on any JS platform.
+
+ This file implements some AST processors. They work on data built
+ by parse-js.
+
+ Exported functions:
+
+ - ast_mangle(ast, options) -- mangles the variable/function names
+ in the AST. Returns an AST.
+
+ - ast_squeeze(ast) -- employs various optimizations to make the
+ final generated code even smaller. Returns an AST.
+
+ - gen_code(ast, options) -- generates JS code from the AST. Pass
+ true (or an object, see the code for some options) as second
+ argument to get "pretty" (indented) code.
+
+ -------------------------------- (C) ---------------------------------
+
+ Author: Mihai Bazon
+ <mihai.bazon@gmail.com>
+ http://mihai.bazon.net/blog
+
+ Distributed under the BSD license:
+
+ Copyright 2010 (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.
+
+ ***********************************************************************/
+
+var jsp = require("./parse-js"),
+ slice = jsp.slice,
+ member = jsp.member,
+ PRECEDENCE = jsp.PRECEDENCE,
+ OPERATORS = jsp.OPERATORS;
+
+/* -----[ helper for AST traversal ]----- */
+
+function ast_walker(ast) {
+ function _vardefs(defs) {
+ return [ this[0], MAP(defs, function(def){
+ var a = [ def[0] ];
+ if (def.length > 1)
+ a[1] = walk(def[1]);
+ return a;
+ }) ];
+ };
+ function _block(statements) {
+ var out = [ this[0] ];
+ if (statements != null)
+ out.push(MAP(statements, walk));
+ return out;
+ };
+ var walkers = {
+ "string": function(str) {
+ return [ this[0], str ];
+ },
+ "num": function(num) {
+ return [ this[0], num ];
+ },
+ "name": function(name) {
+ return [ this[0], name ];
+ },
+ "toplevel": function(statements) {
+ return [ this[0], MAP(statements, walk) ];
+ },
+ "block": _block,
+ "splice": _block,
+ "var": _vardefs,
+ "const": _vardefs,
+ "try": function(t, c, f) {
+ return [
+ this[0],
+ MAP(t, walk),
+ c != null ? [ c[0], MAP(c[1], walk) ] : null,
+ f != null ? MAP(f, walk) : null
+ ];
+ },
+ "throw": function(expr) {
+ return [ this[0], walk(expr) ];
+ },
+ "new": function(ctor, args) {
+ return [ this[0], walk(ctor), MAP(args, walk) ];
+ },
+ "switch": function(expr, body) {
+ return [ this[0], walk(expr), MAP(body, function(branch){
+ return [ branch[0] ? walk(branch[0]) : null,
+ MAP(branch[1], walk) ];
+ }) ];
+ },
+ "break": function(label) {
+ return [ this[0], label ];
+ },
+ "continue": function(label) {
+ return [ this[0], label ];
+ },
+ "conditional": function(cond, t, e) {
+ return [ this[0], walk(cond), walk(t), walk(e) ];
+ },
+ "assign": function(op, lvalue, rvalue) {
+ return [ this[0], op, walk(lvalue), walk(rvalue) ];
+ },
+ "dot": function(expr) {
+ return [ this[0], walk(expr) ].concat(slice(arguments, 1));
+ },
+ "call": function(expr, args) {
+ return [ this[0], walk(expr), MAP(args, walk) ];
+ },
+ "function": function(name, args, body) {
+ return [ this[0], name, args.slice(), MAP(body, walk) ];
+ },
+ "defun": function(name, args, body) {
+ return [ this[0], name, args.slice(), MAP(body, walk) ];
+ },
+ "if": function(conditional, t, e) {
+ return [ this[0], walk(conditional), walk(t), walk(e) ];
+ },
+ "for": function(init, cond, step, block) {
+ return [ this[0], walk(init), walk(cond), walk(step), walk(block) ];
+ },
+ "for-in": function(vvar, key, hash, block) {
+ return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ];
+ },
+ "while": function(cond, block) {
+ return [ this[0], walk(cond), walk(block) ];
+ },
+ "do": function(cond, block) {
+ return [ this[0], walk(cond), walk(block) ];
+ },
+ "return": function(expr) {
+ return [ this[0], walk(expr) ];
+ },
+ "binary": function(op, left, right) {
+ return [ this[0], op, walk(left), walk(right) ];
+ },
+ "unary-prefix": function(op, expr) {
+ return [ this[0], op, walk(expr) ];
+ },
+ "unary-postfix": function(op, expr) {
+ return [ this[0], op, walk(expr) ];
+ },
+ "sub": function(expr, subscript) {
+ return [ this[0], walk(expr), walk(subscript) ];
+ },
+ "object": function(props) {
+ return [ this[0], MAP(props, function(p){
+ return p.length == 2
+ ? [ p[0], walk(p[1]) ]
+ : [ p[0], walk(p[1]), p[2] ]; // get/set-ter
+ }) ];
+ },
+ "regexp": function(rx, mods) {
+ return [ this[0], rx, mods ];
+ },
+ "array": function(elements) {
+ return [ this[0], MAP(elements, walk) ];
+ },
+ "stat": function(stat) {
+ return [ this[0], walk(stat) ];
+ },
+ "seq": function() {
+ return [ this[0] ].concat(MAP(slice(arguments), walk));
+ },
+ "label": function(name, block) {
+ return [ this[0], name, walk(block) ];
+ },
+ "with": function(expr, block) {
+ return [ this[0], walk(expr), walk(block) ];
+ },
+ "atom": function(name) {
+ return [ this[0], name ];
+ }
+ };
+
+ var user = {};
+ var stack = [];
+ function walk(ast) {
+ if (ast == null)
+ return null;
+ try {
+ stack.push(ast);
+ var type = ast[0];
+ var gen = user[type];
+ if (gen) {
+ var ret = gen.apply(ast, ast.slice(1));
+ if (ret != null)
+ return ret;
+ }
+ gen = walkers[type];
+ return gen.apply(ast, ast.slice(1));
+ } finally {
+ stack.pop();
+ }
+ };
+
+ function with_walkers(walkers, cont){
+ var save = {}, i;
+ for (i in walkers) if (HOP(walkers, i)) {
+ save[i] = user[i];
+ user[i] = walkers[i];
+ }
+ var ret = cont();
+ for (i in save) if (HOP(save, i)) {
+ if (!save[i]) delete user[i];
+ else user[i] = save[i];
+ }
+ return ret;
+ };
+
+ return {
+ walk: walk,
+ with_walkers: with_walkers,
+ parent: function() {
+ return stack[stack.length - 2]; // last one is current node
+ },
+ stack: function() {
+ return stack;
+ }
+ };
+};
+
+/* -----[ Scope and mangling ]----- */
+
+function Scope(parent) {
+ this.names = {}; // names defined in this scope
+ this.mangled = {}; // mangled names (orig.name => mangled)
+ this.rev_mangled = {}; // reverse lookup (mangled => orig.name)
+ this.cname = -1; // current mangled name
+ this.refs = {}; // names referenced from this scope
+ this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes
+ this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes
+ this.parent = parent; // parent scope
+ this.children = []; // sub-scopes
+ if (parent) {
+ this.level = parent.level + 1;
+ parent.children.push(this);
+ } else {
+ this.level = 0;
+ }
+};
+
+var base54 = (function(){
+ var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_";
+ return function(num) {
+ var ret = "";
+ do {
+ ret = DIGITS.charAt(num % 54) + ret;
+ num = Math.floor(num / 54);
+ } while (num > 0);
+ return ret;
+ };
+})();
+
+Scope.prototype = {
+ has: function(name) {
+ for (var s = this; s; s = s.parent)
+ if (HOP(s.names, name))
+ return s;
+ },
+ has_mangled: function(mname) {
+ for (var s = this; s; s = s.parent)
+ if (HOP(s.rev_mangled, mname))
+ return s;
+ },
+ toJSON: function() {
+ return {
+ names: this.names,
+ uses_eval: this.uses_eval,
+ uses_with: this.uses_with
+ };
+ },
+
+ next_mangled: function() {
+ // we must be careful that the new mangled name:
+ //
+ // 1. doesn't shadow a mangled name from a parent
+ // scope, unless we don't reference the original
+ // name from this scope OR from any sub-scopes!
+ // This will get slow.
+ //
+ // 2. doesn't shadow an original name from a parent
+ // scope, in the event that the name is not mangled
+ // in the parent scope and we reference that name
+ // here OR IN ANY SUBSCOPES!
+ //
+ // 3. doesn't shadow a name that is referenced but not
+ // defined (possibly global defined elsewhere).
+ for (;;) {
+ var m = base54(++this.cname), prior;
+
+ // case 1.
+ prior = this.has_mangled(m);
+ if (prior && this.refs[prior.rev_mangled[m]] === prior)
+ continue;
+
+ // case 2.
+ prior = this.has(m);
+ if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m))
+ continue;
+
+ // case 3.
+ if (HOP(this.refs, m) && this.refs[m] == null)
+ continue;
+
+ // I got "do" once. :-/
+ if (!is_identifier(m))
+ continue;
+
+ return m;
+ }
+ },
+ set_mangle: function(name, m) {
+ this.rev_mangled[m] = name;
+ return this.mangled[name] = m;
+ },
+ get_mangled: function(name, newMangle) {
+ if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use
+ var s = this.has(name);
+ if (!s) return name; // not in visible scope, no mangle
+ if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope
+ if (!newMangle) return name; // not found and no mangling requested
+ return s.set_mangle(name, s.next_mangled());
+ },
+ define: function(name) {
+ if (name != null)
+ return this.names[name] = name;
+ }
+};
+
+function ast_add_scope(ast) {
+
+ var current_scope = null;
+ var w = ast_walker(), walk = w.walk;
+ var having_eval = [];
+
+ function with_new_scope(cont) {
+ current_scope = new Scope(current_scope);
+ var ret = current_scope.body = cont();
+ ret.scope = current_scope;
+ current_scope = current_scope.parent;
+ return ret;
+ };
+
+ function define(name) {
+ return current_scope.define(name);
+ };
+
+ function reference(name) {
+ current_scope.refs[name] = true;
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun";
+ return [ this[0], is_defun ? define(name) : name, args, with_new_scope(function(){
+ if (!is_defun) define(name);
+ MAP(args, define);
+ return MAP(body, walk);
+ })];
+ };
+
+ return with_new_scope(function(){
+ // process AST
+ var ret = w.with_walkers({
+ "function": _lambda,
+ "defun": _lambda,
+ "with": function(expr, block) {
+ for (var s = current_scope; s; s = s.parent)
+ s.uses_with = true;
+ },
+ "var": function(defs) {
+ MAP(defs, function(d){ define(d[0]) });
+ },
+ "const": function(defs) {
+ MAP(defs, function(d){ define(d[0]) });
+ },
+ "try": function(t, c, f) {
+ if (c != null) return [
+ this[0],
+ MAP(t, walk),
+ [ define(c[0]), MAP(c[1], walk) ],
+ f != null ? MAP(f, walk) : null
+ ];
+ },
+ "name": function(name) {
+ if (name == "eval")
+ having_eval.push(current_scope);
+ reference(name);
+ }
+ }, function(){
+ return walk(ast);
+ });
+
+ // the reason why we need an additional pass here is
+ // that names can be used prior to their definition.
+
+ // scopes where eval was detected and their parents
+ // are marked with uses_eval, unless they define the
+ // "eval" name.
+ MAP(having_eval, function(scope){
+ if (!scope.has("eval")) while (scope) {
+ scope.uses_eval = true;
+ scope = scope.parent;
+ }
+ });
+
+ // for referenced names it might be useful to know
+ // their origin scope. current_scope here is the
+ // toplevel one.
+ function fixrefs(scope, i) {
+ // do children first; order shouldn't matter
+ for (i = scope.children.length; --i >= 0;)
+ fixrefs(scope.children[i]);
+ for (i in scope.refs) if (HOP(scope.refs, i)) {
+ // find origin scope and propagate the reference to origin
+ for (var origin = scope.has(i), s = scope; s; s = s.parent) {
+ s.refs[i] = origin;
+ if (s === origin) break;
+ }
+ }
+ };
+ fixrefs(current_scope);
+
+ return ret;
+ });
+
+};
+
+/* -----[ mangle names ]----- */
+
+function ast_mangle(ast, options) {
+ var w = ast_walker(), walk = w.walk, scope;
+ options = options || {};
+
+ function get_mangled(name, newMangle) {
+ if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel
+ if (options.except && member(name, options.except))
+ return name;
+ return scope.get_mangled(name, newMangle);
+ };
+
+ function get_define(name) {
+ if (options.defines) {
+ // we always lookup a defined symbol for the current scope FIRST, so declared
+ // vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value
+ if (!scope.has(name)) {
+ if (HOP(options.defines, name)) {
+ return options.defines[name];
+ }
+ }
+ return null;
+ }
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun", extra;
+ if (name) {
+ if (is_defun) name = get_mangled(name);
+ else {
+ extra = {};
+ if (!(scope.uses_eval || scope.uses_with))
+ name = extra[name] = scope.next_mangled();
+ else
+ extra[name] = name;
+ }
+ }
+ body = with_scope(body.scope, function(){
+ args = MAP(args, function(name){ return get_mangled(name) });
+ return MAP(body, walk);
+ }, extra);
+ return [ this[0], name, args, body ];
+ };
+
+ function with_scope(s, cont, extra) {
+ var _scope = scope;
+ scope = s;
+ if (extra) for (var i in extra) if (HOP(extra, i)) {
+ s.set_mangle(i, extra[i]);
+ }
+ for (var i in s.names) if (HOP(s.names, i)) {
+ get_mangled(i, true);
+ }
+ var ret = cont();
+ ret.scope = s;
+ scope = _scope;
+ return ret;
+ };
+
+ function _vardefs(defs) {
+ return [ this[0], MAP(defs, function(d){
+ return [ get_mangled(d[0]), walk(d[1]) ];
+ }) ];
+ };
+
+ return w.with_walkers({
+ "function": _lambda,
+ "defun": function() {
+ // move function declarations to the top when
+ // they are not in some block.
+ var ast = _lambda.apply(this, arguments);
+ switch (w.parent()[0]) {
+ case "toplevel":
+ case "function":
+ case "defun":
+ return MAP.at_top(ast);
+ }
+ return ast;
+ },
+ "var": _vardefs,
+ "const": _vardefs,
+ "name": function(name) {
+ return get_define(name) || [ this[0], get_mangled(name) ];
+ },
+ "try": function(t, c, f) {
+ return [ this[0],
+ MAP(t, walk),
+ c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null,
+ f != null ? MAP(f, walk) : null ];
+ },
+ "toplevel": function(body) {
+ var self = this;
+ return with_scope(self.scope, function(){
+ return [ self[0], MAP(body, walk) ];
+ });
+ }
+ }, function() {
+ return walk(ast_add_scope(ast));
+ });
+};
+
+/* -----[
+ - compress foo["bar"] into foo.bar,
+ - remove block brackets {} where possible
+ - join consecutive var declarations
+ - various optimizations for IFs:
+ - if (cond) foo(); else bar(); ==> cond?foo():bar();
+ - if (cond) foo(); ==> cond&&foo();
+ - if (foo) return bar(); else return baz(); ==> return foo?bar():baz(); // also for throw
+ - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+ ]----- */
+
+var warn = function(){};
+
+function best_of(ast1, ast2) {
+ return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1;
+};
+
+function last_stat(b) {
+ if (b[0] == "block" && b[1] && b[1].length > 0)
+ return b[1][b[1].length - 1];
+ return b;
+}
+
+function aborts(t) {
+ if (t) {
+ t = last_stat(t);
+ if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw")
+ return true;
+ }
+};
+
+function boolean_expr(expr) {
+ return ( (expr[0] == "unary-prefix"
+ && member(expr[1], [ "!", "delete" ])) ||
+
+ (expr[0] == "binary"
+ && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) ||
+
+ (expr[0] == "binary"
+ && member(expr[1], [ "&&", "||" ])
+ && boolean_expr(expr[2])
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "conditional"
+ && boolean_expr(expr[2])
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "assign"
+ && expr[1] === true
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "seq"
+ && boolean_expr(expr[expr.length - 1]))
+ );
+};
+
+function make_conditional(c, t, e) {
+ var make_real_conditional = function() {
+ if (c[0] == "unary-prefix" && c[1] == "!") {
+ return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ];
+ } else {
+ return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ];
+ }
+ };
+ // shortcut the conditional if the expression has a constant value
+ return when_constant(c, function(ast, val){
+ warn_unreachable(val ? e : t);
+ return (val ? t : e);
+ }, make_real_conditional);
+};
+
+function empty(b) {
+ return !b || (b[0] == "block" && (!b[1] || b[1].length == 0));
+};
+
+function is_string(node) {
+ return (node[0] == "string" ||
+ node[0] == "unary-prefix" && node[1] == "typeof" ||
+ node[0] == "binary" && node[1] == "+" &&
+ (is_string(node[2]) || is_string(node[3])));
+};
+
+var when_constant = (function(){
+
+ var $NOT_CONSTANT = {};
+
+ // this can only evaluate constant expressions. If it finds anything
+ // not constant, it throws $NOT_CONSTANT.
+ function evaluate(expr) {
+ switch (expr[0]) {
+ case "string":
+ case "num":
+ return expr[1];
+ case "name":
+ case "atom":
+ switch (expr[1]) {
+ case "true": return true;
+ case "false": return false;
+ }
+ break;
+ case "unary-prefix":
+ switch (expr[1]) {
+ case "!": return !evaluate(expr[2]);
+ case "typeof": return typeof evaluate(expr[2]);
+ case "~": return ~evaluate(expr[2]);
+ case "-": return -evaluate(expr[2]);
+ case "+": return +evaluate(expr[2]);
+ }
+ break;
+ case "binary":
+ var left = expr[2], right = expr[3];
+ switch (expr[1]) {
+ case "&&" : return evaluate(left) && evaluate(right);
+ case "||" : return evaluate(left) || evaluate(right);
+ case "|" : return evaluate(left) | evaluate(right);
+ case "&" : return evaluate(left) & evaluate(right);
+ case "^" : return evaluate(left) ^ evaluate(right);
+ case "+" : return evaluate(left) + evaluate(right);
+ case "*" : return evaluate(left) * evaluate(right);
+ case "/" : return evaluate(left) / evaluate(right);
+ case "-" : return evaluate(left) - evaluate(right);
+ case "<<" : return evaluate(left) << evaluate(right);
+ case ">>" : return evaluate(left) >> evaluate(right);
+ case ">>>" : return evaluate(left) >>> evaluate(right);
+ case "==" : return evaluate(left) == evaluate(right);
+ case "===" : return evaluate(left) === evaluate(right);
+ case "!=" : return evaluate(left) != evaluate(right);
+ case "!==" : return evaluate(left) !== evaluate(right);
+ case "<" : return evaluate(left) < evaluate(right);
+ case "<=" : return evaluate(left) <= evaluate(right);
+ case ">" : return evaluate(left) > evaluate(right);
+ case ">=" : return evaluate(left) >= evaluate(right);
+ case "in" : return evaluate(left) in evaluate(right);
+ case "instanceof" : return evaluate(left) instanceof evaluate(right);
+ }
+ }
+ throw $NOT_CONSTANT;
+ };
+
+ return function(expr, yes, no) {
+ try {
+ var val = evaluate(expr), ast;
+ switch (typeof val) {
+ case "string": ast = [ "string", val ]; break;
+ case "number": ast = [ "num", val ]; break;
+ case "boolean": ast = [ "name", String(val) ]; break;
+ default: throw new Error("Can't handle constant of type: " + (typeof val));
+ }
+ return yes.call(expr, ast, val);
+ } catch(ex) {
+ if (ex === $NOT_CONSTANT) {
+ if (expr[0] == "binary"
+ && (expr[1] == "===" || expr[1] == "!==")
+ && ((is_string(expr[2]) && is_string(expr[3]))
+ || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) {
+ expr[1] = expr[1].substr(0, 2);
+ }
+ else if (no && expr[0] == "binary"
+ && (expr[1] == "||" || expr[1] == "&&")) {
+ // the whole expression is not constant but the lval may be...
+ try {
+ var lval = evaluate(expr[2]);
+ expr = ((expr[1] == "&&" && (lval ? expr[3] : lval)) ||
+ (expr[1] == "||" && (lval ? lval : expr[3])) ||
+ expr);
+ } catch(ex2) {
+ // IGNORE... lval is not constant
+ }
+ }
+ return no ? no.call(expr, expr) : null;
+ }
+ else throw ex;
+ }
+ };
+
+})();
+
+function warn_unreachable(ast) {
+ if (!empty(ast))
+ warn("Dropping unreachable code: " + gen_code(ast, true));
+};
+
+function prepare_ifs(ast) {
+ var w = ast_walker(), walk = w.walk;
+ // In this first pass, we rewrite ifs which abort with no else with an
+ // if-else. For example:
+ //
+ // if (x) {
+ // blah();
+ // return y;
+ // }
+ // foobar();
+ //
+ // is rewritten into:
+ //
+ // if (x) {
+ // blah();
+ // return y;
+ // } else {
+ // foobar();
+ // }
+ function redo_if(statements) {
+ statements = MAP(statements, walk);
+
+ for (var i = 0; i < statements.length; ++i) {
+ var fi = statements[i];
+ if (fi[0] != "if") continue;
+
+ if (fi[3] && walk(fi[3])) continue;
+
+ var t = walk(fi[2]);
+ if (!aborts(t)) continue;
+
+ var conditional = walk(fi[1]);
+
+ var e_body = statements.slice(i + 1);
+ var e;
+ if (e_body.length == 1) e = e_body[0];
+ else e = [ "block", e_body ];
+
+ var ret = statements.slice(0, i).concat([ [
+ fi[0], // "if"
+ conditional, // conditional
+ t, // then
+ e // else
+ ] ]);
+
+ return redo_if(ret);
+ }
+
+ return statements;
+ };
+
+ function redo_if_lambda(name, args, body) {
+ body = redo_if(body);
+ return [ this[0], name, args.slice(), body ];
+ };
+
+ function redo_if_block(statements) {
+ var out = [ this[0] ];
+ if (statements != null)
+ out.push(redo_if(statements));
+ return out;
+ };
+
+ return w.with_walkers({
+ "defun": redo_if_lambda,
+ "function": redo_if_lambda,
+ "block": redo_if_block,
+ "splice": redo_if_block,
+ "toplevel": function(statements) {
+ return [ this[0], redo_if(statements) ];
+ },
+ "try": function(t, c, f) {
+ return [
+ this[0],
+ redo_if(t),
+ c != null ? [ c[0], redo_if(c[1]) ] : null,
+ f != null ? redo_if(f) : null
+ ];
+ }
+ }, function() {
+ return walk(ast);
+ });
+};
+
+function ast_squeeze(ast, options) {
+ options = defaults(options, {
+ make_seqs : true,
+ dead_code : true,
+ keep_comps : true,
+ no_warnings : false
+ });
+
+ var w = ast_walker(), walk = w.walk, scope;
+
+ function negate(c) {
+ var not_c = [ "unary-prefix", "!", c ];
+ switch (c[0]) {
+ case "unary-prefix":
+ return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c;
+ case "seq":
+ c = slice(c);
+ c[c.length - 1] = negate(c[c.length - 1]);
+ return c;
+ case "conditional":
+ return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]);
+ case "binary":
+ var op = c[1], left = c[2], right = c[3];
+ if (!options.keep_comps) switch (op) {
+ case "<=" : return [ "binary", ">", left, right ];
+ case "<" : return [ "binary", ">=", left, right ];
+ case ">=" : return [ "binary", "<", left, right ];
+ case ">" : return [ "binary", "<=", left, right ];
+ }
+ switch (op) {
+ case "==" : return [ "binary", "!=", left, right ];
+ case "!=" : return [ "binary", "==", left, right ];
+ case "===" : return [ "binary", "!==", left, right ];
+ case "!==" : return [ "binary", "===", left, right ];
+ case "&&" : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]);
+ case "||" : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]);
+ }
+ break;
+ }
+ return not_c;
+ };
+
+ function with_scope(s, cont) {
+ var _scope = scope;
+ scope = s;
+ var ret = cont();
+ ret.scope = s;
+ scope = _scope;
+ return ret;
+ };
+
+ function rmblock(block) {
+ if (block != null && block[0] == "block" && block[1]) {
+ if (block[1].length == 1)
+ block = block[1][0];
+ else if (block[1].length == 0)
+ block = [ "block" ];
+ }
+ return block;
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun";
+ body = with_scope(body.scope, function(){
+ var ret = tighten(MAP(body, walk), "lambda");
+ if (!is_defun && name && !HOP(scope.refs, name))
+ name = null;
+ return ret;
+ });
+ return [ this[0], name, args, body ];
+ };
+
+ // we get here for blocks that have been already transformed.
+ // this function does a few things:
+ // 1. discard useless blocks
+ // 2. join consecutive var declarations
+ // 3. remove obviously dead code
+ // 4. transform consecutive statements using the comma operator
+ // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
+ function tighten(statements, block_type) {
+ statements = statements.reduce(function(a, stat){
+ if (stat[0] == "block") {
+ if (stat[1]) {
+ a.push.apply(a, stat[1]);
+ }
+ } else {
+ a.push(stat);
+ }
+ return a;
+ }, []);
+
+ statements = (function(a, prev){
+ statements.forEach(function(cur){
+ if (prev && ((cur[0] == "var" && prev[0] == "var") ||
+ (cur[0] == "const" && prev[0] == "const"))) {
+ prev[1] = prev[1].concat(cur[1]);
+ } else {
+ a.push(cur);
+ prev = cur;
+ }
+ });
+ return a;
+ })([]);
+
+ if (options.dead_code) statements = (function(a, has_quit){
+ statements.forEach(function(st){
+ if (has_quit) {
+ if (member(st[0], [ "function", "defun" , "var", "const" ])) {
+ a.push(st);
+ }
+ else if (!options.no_warnings)
+ warn_unreachable(st);
+ }
+ else {
+ a.push(st);
+ if (member(st[0], [ "return", "throw", "break", "continue" ]))
+ has_quit = true;
+ }
+ });
+ return a;
+ })([]);
+
+ if (options.make_seqs) statements = (function(a, prev) {
+ statements.forEach(function(cur){
+ if (prev && prev[0] == "stat" && cur[0] == "stat") {
+ prev[1] = [ "seq", prev[1], cur[1] ];
+ } else {
+ a.push(cur);
+ prev = cur;
+ }
+ });
+ return a;
+ })([]);
+
+ if (block_type == "lambda") statements = (function(i, a, stat){
+ while (i < statements.length) {
+ stat = statements[i++];
+ if (stat[0] == "if" && !stat[3]) {
+ if (stat[2][0] == "return" && stat[2][1] == null) {
+ a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
+ break;
+ }
+ var last = last_stat(stat[2]);
+ if (last[0] == "return" && last[1] == null) {
+ a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
+ break;
+ }
+ }
+ a.push(stat);
+ }
+ return a;
+ })(0, []);
+
+ return statements;
+ };
+
+ function make_if(c, t, e) {
+ return when_constant(c, function(ast, val){
+ if (val) {
+ warn_unreachable(e);
+ return t;
+ } else {
+ warn_unreachable(t);
+ return e;
+ }
+ }, function() {
+ return make_real_if(c, t, e);
+ });
+ };
+
+ function make_real_if(c, t, e) {
+ c = walk(c);
+ t = walk(t);
+ e = walk(e);
+
+ if (empty(t)) {
+ c = negate(c);
+ t = e;
+ e = null;
+ } else if (empty(e)) {
+ e = null;
+ } else {
+ // if we have both else and then, maybe it makes sense to switch them?
+ (function(){
+ var a = gen_code(c);
+ var n = negate(c);
+ var b = gen_code(n);
+ if (b.length < a.length) {
+ var tmp = t;
+ t = e;
+ e = tmp;
+ c = n;
+ }
+ })();
+ }
+ if (empty(e) && empty(t))
+ return [ "stat", c ];
+ var ret = [ "if", c, t, e ];
+ if (t[0] == "if" && empty(t[3]) && empty(e)) {
+ ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ]));
+ }
+ else if (t[0] == "stat") {
+ if (e) {
+ if (e[0] == "stat") {
+ ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]);
+ }
+ }
+ else {
+ ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]);
+ }
+ }
+ else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) {
+ ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]);
+ }
+ else if (e && aborts(t)) {
+ ret = [ [ "if", c, t ] ];
+ if (e[0] == "block") {
+ if (e[1]) ret = ret.concat(e[1]);
+ }
+ else {
+ ret.push(e);
+ }
+ ret = walk([ "block", ret ]);
+ }
+ else if (t && aborts(e)) {
+ ret = [ [ "if", negate(c), e ] ];
+ if (t[0] == "block") {
+ if (t[1]) ret = ret.concat(t[1]);
+ } else {
+ ret.push(t);
+ }
+ ret = walk([ "block", ret ]);
+ }
+ return ret;
+ };
+
+ function _do_while(cond, body) {
+ return when_constant(cond, function(cond, val){
+ if (!val) {
+ warn_unreachable(body);
+ return [ "block" ];
+ } else {
+ return [ "for", null, null, null, walk(body) ];
+ }
+ });
+ };
+
+ ast = prepare_ifs(ast);
+ ast = ast_add_scope(ast);
+
+ return w.with_walkers({
+ "sub": function(expr, subscript) {
+ if (subscript[0] == "string") {
+ var name = subscript[1];
+ if (is_identifier(name))
+ return [ "dot", walk(expr), name ];
+ else if (/^[1-9][0-9]*$/.test(name) || name === "0")
+ return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ];
+ }
+ },
+ "if": make_if,
+ "toplevel": function(body) {
+ return [ "toplevel", with_scope(this.scope, function(){
+ return tighten(MAP(body, walk));
+ }) ];
+ },
+ "switch": function(expr, body) {
+ var last = body.length - 1;
+ return [ "switch", walk(expr), MAP(body, function(branch, i){
+ var block = tighten(MAP(branch[1], walk));
+ if (i == last && block.length > 0) {
+ var node = block[block.length - 1];
+ if (node[0] == "break" && !node[1])
+ block.pop();
+ }
+ return [ branch[0] ? walk(branch[0]) : null, block ];
+ }) ];
+ },
+ "function": _lambda,
+ "defun": _lambda,
+ "block": function(body) {
+ if (body) return rmblock([ "block", tighten(MAP(body, walk)) ]);
+ },
+ "binary": function(op, left, right) {
+ return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){
+ return best_of(walk(c), this);
+ }, function no() {
+ return this;
+ });
+ },
+ "conditional": function(c, t, e) {
+ return make_conditional(walk(c), walk(t), walk(e));
+ },
+ "try": function(t, c, f) {
+ return [
+ "try",
+ tighten(MAP(t, walk)),
+ c != null ? [ c[0], tighten(MAP(c[1], walk)) ] : null,
+ f != null ? tighten(MAP(f, walk)) : null
+ ];
+ },
+ "unary-prefix": function(op, expr) {
+ expr = walk(expr);
+ var ret = [ "unary-prefix", op, expr ];
+ if (op == "!")
+ ret = best_of(ret, negate(expr));
+ return when_constant(ret, function(ast, val){
+ return walk(ast); // it's either true or false, so minifies to !0 or !1
+ }, function() { return ret });
+ },
+ "name": function(name) {
+ switch (name) {
+ case "true": return [ "unary-prefix", "!", [ "num", 0 ]];
+ case "false": return [ "unary-prefix", "!", [ "num", 1 ]];
+ }
+ },
+ "new": function(ctor, args) {
+ if (ctor[0] == "name" && ctor[1] == "Array" && !scope.has("Array")) {
+ if (args.length != 1) {
+ return [ "array", args ];
+ } else {
+ return [ "call", [ "name", "Array" ], args ];
+ }
+ }
+ },
+ "call": function(expr, args) {
+ if (expr[0] == "name" && expr[1] == "Array" && args.length != 1 && !scope.has("Array")) {
+ return [ "array", args ];
+ }
+ },
+ "while": _do_while
+ }, function() {
+ return walk(ast);
+ });
+};
+
+/* -----[ re-generate code from the AST ]----- */
+
+var DOT_CALL_NO_PARENS = jsp.array_to_hash([
+ "name",
+ "array",
+ "object",
+ "string",
+ "dot",
+ "sub",
+ "call",
+ "regexp"
+]);
+
+function make_string(str, ascii_only) {
+ var dq = 0, sq = 0;
+ str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){
+ switch (s) {
+ case "\\": return "\\\\";
+ case "\b": return "\\b";
+ case "\f": return "\\f";
+ case "\n": return "\\n";
+ case "\r": return "\\r";
+ case "\t": return "\\t";
+ case "\u2028": return "\\u2028";
+ case "\u2029": return "\\u2029";
+ case '"': ++dq; return '"';
+ case "'": ++sq; return "'";
+ }
+ return s;
+ });
+ if (ascii_only) str = to_ascii(str);
+ if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'";
+ else return '"' + str.replace(/\x22/g, '\\"') + '"';
+};
+
+function to_ascii(str) {
+ return str.replace(/[\u0080-\uffff]/g, function(ch) {
+ var code = ch.charCodeAt(0).toString(16);
+ while (code.length < 4) code = "0" + code;
+ return "\\u" + code;
+ });
+};
+
+var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]);
+
+function gen_code(ast, options) {
+ options = defaults(options, {
+ indent_start : 0,
+ indent_level : 4,
+ quote_keys : false,
+ space_colon : false,
+ beautify : false,
+ ascii_only : false,
+ inline_script: false
+ });
+ var beautify = !!options.beautify;
+ var indentation = 0,
+ newline = beautify ? "\n" : "",
+ space = beautify ? " " : "";
+
+ function encode_string(str) {
+ var ret = make_string(str, options.ascii_only);
+ if (options.inline_script)
+ ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1");
+ return ret;
+ };
+
+ function make_name(name) {
+ name = name.toString();
+ if (options.ascii_only)
+ name = to_ascii(name);
+ return name;
+ };
+
+ function indent(line) {
+ if (line == null)
+ line = "";
+ if (beautify)
+ line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line;
+ return line;
+ };
+
+ function with_indent(cont, incr) {
+ if (incr == null) incr = 1;
+ indentation += incr;
+ try { return cont.apply(null, slice(arguments, 1)); }
+ finally { indentation -= incr; }
+ };
+
+ function add_spaces(a) {
+ if (beautify)
+ return a.join(" ");
+ var b = [];
+ for (var i = 0; i < a.length; ++i) {
+ var next = a[i + 1];
+ b.push(a[i]);
+ if (next &&
+ ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) ||
+ (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) {
+ b.push(" ");
+ }
+ }
+ return b.join("");
+ };
+
+ function add_commas(a) {
+ return a.join("," + space);
+ };
+
+ function parenthesize(expr) {
+ var gen = make(expr);
+ for (var i = 1; i < arguments.length; ++i) {
+ var el = arguments[i];
+ if ((el instanceof Function && el(expr)) || expr[0] == el)
+ return "(" + gen + ")";
+ }
+ return gen;
+ };
+
+ function best_of(a) {
+ if (a.length == 1) {
+ return a[0];
+ }
+ if (a.length == 2) {
+ var b = a[1];
+ a = a[0];
+ return a.length <= b.length ? a : b;
+ }
+ return best_of([ a[0], best_of(a.slice(1)) ]);
+ };
+
+ function needs_parens(expr) {
+ if (expr[0] == "function" || expr[0] == "object") {
+ // dot/call on a literal function requires the
+ // function literal itself to be parenthesized
+ // only if it's the first "thing" in a
+ // statement. This means that the parent is
+ // "stat", but it could also be a "seq" and
+ // we're the first in this "seq" and the
+ // parent is "stat", and so on. Messy stuff,
+ // but it worths the trouble.
+ var a = slice($stack), self = a.pop(), p = a.pop();
+ while (p) {
+ if (p[0] == "stat") return true;
+ if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) ||
+ ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) {
+ self = p;
+ p = a.pop();
+ } else {
+ return false;
+ }
+ }
+ }
+ return !HOP(DOT_CALL_NO_PARENS, expr[0]);
+ };
+
+ function make_num(num) {
+ var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m;
+ if (Math.floor(num) === num) {
+ a.push("0x" + num.toString(16).toLowerCase(), // probably pointless
+ "0" + num.toString(8)); // same.
+ if ((m = /^(.*?)(0+)$/.exec(num))) {
+ a.push(m[1] + "e" + m[2].length);
+ }
+ } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
+ a.push(m[2] + "e-" + (m[1].length + m[2].length),
+ str.substr(str.indexOf(".")));
+ }
+ return best_of(a);
+ };
+
+ var generators = {
+ "string": encode_string,
+ "num": make_num,
+ "name": make_name,
+ "toplevel": function(statements) {
+ return make_block_statements(statements)
+ .join(newline + newline);
+ },
+ "splice": function(statements) {
+ var parent = $stack[$stack.length - 2][0];
+ if (HOP(SPLICE_NEEDS_BRACKETS, parent)) {
+ // we need block brackets in this case
+ return make_block.apply(this, arguments);
+ } else {
+ return MAP(make_block_statements(statements, true),
+ function(line, i) {
+ // the first line is already indented
+ return i > 0 ? indent(line) : line;
+ }).join(newline);
+ }
+ },
+ "block": make_block,
+ "var": function(defs) {
+ return "var " + add_commas(MAP(defs, make_1vardef)) + ";";
+ },
+ "const": function(defs) {
+ return "const " + add_commas(MAP(defs, make_1vardef)) + ";";
+ },
+ "try": function(tr, ca, fi) {
+ var out = [ "try", make_block(tr) ];
+ if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1]));
+ if (fi) out.push("finally", make_block(fi));
+ return add_spaces(out);
+ },
+ "throw": function(expr) {
+ return add_spaces([ "throw", make(expr) ]) + ";";
+ },
+ "new": function(ctor, args) {
+ args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : "";
+ return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){
+ var w = ast_walker(), has_call = {};
+ try {
+ w.with_walkers({
+ "call": function() { throw has_call },
+ "function": function() { return this }
+ }, function(){
+ w.walk(expr);
+ });
+ } catch(ex) {
+ if (ex === has_call)
+ return true;
+ throw ex;
+ }
+ }) + args ]);
+ },
+ "switch": function(expr, body) {
+ return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]);
+ },
+ "break": function(label) {
+ var out = "break";
+ if (label != null)
+ out += " " + make_name(label);
+ return out + ";";
+ },
+ "continue": function(label) {
+ var out = "continue";
+ if (label != null)
+ out += " " + make_name(label);
+ return out + ";";
+ },
+ "conditional": function(co, th, el) {
+ return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?",
+ parenthesize(th, "seq"), ":",
+ parenthesize(el, "seq") ]);
+ },
+ "assign": function(op, lvalue, rvalue) {
+ if (op && op !== true) op += "=";
+ else op = "=";
+ return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]);
+ },
+ "dot": function(expr) {
+ var out = make(expr), i = 1;
+ if (expr[0] == "num") {
+ if (!/\./.test(expr[1]))
+ out += ".";
+ } else if (needs_parens(expr))
+ out = "(" + out + ")";
+ while (i < arguments.length)
+ out += "." + make_name(arguments[i++]);
+ return out;
+ },
+ "call": function(func, args) {
+ var f = make(func);
+ if (needs_parens(func))
+ f = "(" + f + ")";
+ return f + "(" + add_commas(MAP(args, function(expr){
+ return parenthesize(expr, "seq");
+ })) + ")";
+ },
+ "function": make_function,
+ "defun": make_function,
+ "if": function(co, th, el) {
+ var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ];
+ if (el) {
+ out.push("else", make(el));
+ }
+ return add_spaces(out);
+ },
+ "for": function(init, cond, step, block) {
+ var out = [ "for" ];
+ init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space);
+ cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space);
+ step = (step != null ? make(step) : "").replace(/;*\s*$/, "");
+ var args = init + cond + step;
+ if (args == "; ; ") args = ";;";
+ out.push("(" + args + ")", make(block));
+ return add_spaces(out);
+ },
+ "for-in": function(vvar, key, hash, block) {
+ return add_spaces([ "for", "(" +
+ (vvar ? make(vvar).replace(/;+$/, "") : make(key)),
+ "in",
+ make(hash) + ")", make(block) ]);
+ },
+ "while": function(condition, block) {
+ return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]);
+ },
+ "do": function(condition, block) {
+ return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";";
+ },
+ "return": function(expr) {
+ var out = [ "return" ];
+ if (expr != null) out.push(make(expr));
+ return add_spaces(out) + ";";
+ },
+ "binary": function(operator, lvalue, rvalue) {
+ var left = make(lvalue), right = make(rvalue);
+ // XXX: I'm pretty sure other cases will bite here.
+ // we need to be smarter.
+ // adding parens all the time is the safest bet.
+ if (member(lvalue[0], [ "assign", "conditional", "seq" ]) ||
+ lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) {
+ left = "(" + left + ")";
+ }
+ if (member(rvalue[0], [ "assign", "conditional", "seq" ]) ||
+ rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] &&
+ !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) {
+ right = "(" + right + ")";
+ }
+ else if (!beautify && options.inline_script && (operator == "<" || operator == "<<")
+ && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) {
+ right = " " + right;
+ }
+ return add_spaces([ left, operator, right ]);
+ },
+ "unary-prefix": function(operator, expr) {
+ var val = make(expr);
+ if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
+ val = "(" + val + ")";
+ return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val;
+ },
+ "unary-postfix": function(operator, expr) {
+ var val = make(expr);
+ if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
+ val = "(" + val + ")";
+ return val + operator;
+ },
+ "sub": function(expr, subscript) {
+ var hash = make(expr);
+ if (needs_parens(expr))
+ hash = "(" + hash + ")";
+ return hash + "[" + make(subscript) + "]";
+ },
+ "object": function(props) {
+ if (props.length == 0)
+ return "{}";
+ return "{" + newline + with_indent(function(){
+ return MAP(props, function(p){
+ if (p.length == 3) {
+ // getter/setter. The name is in p[0], the arg.list in p[1][2], the
+ // body in p[1][3] and type ("get" / "set") in p[2].
+ return indent(make_function(p[0], p[1][2], p[1][3], p[2]));
+ }
+ var key = p[0], val = make(p[1]);
+ if (options.quote_keys) {
+ key = encode_string(key);
+ } else if ((typeof key == "number" || !beautify && +key + "" == key)
+ && parseFloat(key) >= 0) {
+ key = make_num(+key);
+ } else if (!is_identifier(key)) {
+ key = encode_string(key);
+ }
+ return indent(add_spaces(beautify && options.space_colon
+ ? [ key, ":", val ]
+ : [ key + ":", val ]));
+ }).join("," + newline);
+ }) + newline + indent("}");
+ },
+ "regexp": function(rx, mods) {
+ return "/" + rx + "/" + mods;
+ },
+ "array": function(elements) {
+ if (elements.length == 0) return "[]";
+ return add_spaces([ "[", add_commas(MAP(elements, function(el){
+ if (!beautify && el[0] == "atom" && el[1] == "undefined") return "";
+ return parenthesize(el, "seq");
+ })), "]" ]);
+ },
+ "stat": function(stmt) {
+ return make(stmt).replace(/;*\s*$/, ";");
+ },
+ "seq": function() {
+ return add_commas(MAP(slice(arguments), make));
+ },
+ "label": function(name, block) {
+ return add_spaces([ make_name(name), ":", make(block) ]);
+ },
+ "with": function(expr, block) {
+ return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]);
+ },
+ "atom": function(name) {
+ return make_name(name);
+ }
+ };
+
+ // The squeezer replaces "block"-s that contain only a single
+ // statement with the statement itself; technically, the AST
+ // is correct, but this can create problems when we output an
+ // IF having an ELSE clause where the THEN clause ends in an
+ // IF *without* an ELSE block (then the outer ELSE would refer
+ // to the inner IF). This function checks for this case and
+ // adds the block brackets if needed.
+ function make_then(th) {
+ if (th[0] == "do") {
+ // https://github.com/mishoo/UglifyJS/issues/#issue/57
+ // IE croaks with "syntax error" on code like this:
+ // if (foo) do ... while(cond); else ...
+ // we need block brackets around do/while
+ return make([ "block", [ th ]]);
+ }
+ var b = th;
+ while (true) {
+ var type = b[0];
+ if (type == "if") {
+ if (!b[3])
+ // no else, we must add the block
+ return make([ "block", [ th ]]);
+ b = b[3];
+ }
+ else if (type == "while" || type == "do") b = b[2];
+ else if (type == "for" || type == "for-in") b = b[4];
+ else break;
+ }
+ return make(th);
+ };
+
+ function make_function(name, args, body, keyword) {
+ var out = keyword || "function";
+ if (name) {
+ out += " " + make_name(name);
+ }
+ out += "(" + add_commas(MAP(args, make_name)) + ")";
+ return add_spaces([ out, make_block(body) ]);
+ };
+
+ function make_block_statements(statements, noindent) {
+ for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) {
+ var stat = statements[i];
+ var code = make(stat);
+ if (code != ";") {
+ if (!beautify && i == last) {
+ if ((stat[0] == "while" && empty(stat[2])) ||
+ (member(stat[0], [ "for", "for-in"] ) && empty(stat[4])) ||
+ (stat[0] == "if" && empty(stat[2]) && !stat[3]) ||
+ (stat[0] == "if" && stat[3] && empty(stat[3]))) {
+ code = code.replace(/;*\s*$/, ";");
+ } else {
+ code = code.replace(/;+\s*$/, "");
+ }
+ }
+ a.push(code);
+ }
+ }
+ return noindent ? a : MAP(a, indent);
+ };
+
+ function make_switch_block(body) {
+ var n = body.length;
+ if (n == 0) return "{}";
+ return "{" + newline + MAP(body, function(branch, i){
+ var has_body = branch[1].length > 0, code = with_indent(function(){
+ return indent(branch[0]
+ ? add_spaces([ "case", make(branch[0]) + ":" ])
+ : "default:");
+ }, 0.5) + (has_body ? newline + with_indent(function(){
+ return make_block_statements(branch[1]).join(newline);
+ }) : "");
+ if (!beautify && has_body && i < n - 1)
+ code += ";";
+ return code;
+ }).join(newline) + newline + indent("}");
+ };
+
+ function make_block(statements) {
+ if (!statements) return ";";
+ if (statements.length == 0) return "{}";
+ return "{" + newline + with_indent(function(){
+ return make_block_statements(statements).join(newline);
+ }) + newline + indent("}");
+ };
+
+ function make_1vardef(def) {
+ var name = def[0], val = def[1];
+ if (val != null)
+ name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]);
+ return name;
+ };
+
+ var $stack = [];
+
+ function make(node) {
+ var type = node[0];
+ var gen = generators[type];
+ if (!gen)
+ throw new Error("Can't find generator for \"" + type + "\"");
+ $stack.push(node);
+ var ret = gen.apply(type, node.slice(1));
+ $stack.pop();
+ return ret;
+ };
+
+ return make(ast);
+};
+
+function split_lines(code, max_line_length) {
+ var splits = [ 0 ];
+ jsp.parse(function(){
+ var next_token = jsp.tokenizer(code);
+ var last_split = 0;
+ var prev_token;
+ function current_length(tok) {
+ return tok.pos - last_split;
+ };
+ function split_here(tok) {
+ last_split = tok.pos;
+ splits.push(last_split);
+ };
+ function custom(){
+ var tok = next_token.apply(this, arguments);
+ out: {
+ if (prev_token) {
+ if (prev_token.type == "keyword") break out;
+ }
+ if (current_length(tok) > max_line_length) {
+ switch (tok.type) {
+ case "keyword":
+ case "atom":
+ case "name":
+ case "punc":
+ split_here(tok);
+ break out;
+ }
+ }
+ }
+ prev_token = tok;
+ return tok;
+ };
+ custom.context = function() {
+ return next_token.context.apply(this, arguments);
+ };
+ return custom;
+ }());
+ return splits.map(function(pos, i){
+ return code.substring(pos, splits[i + 1] || code.length);
+ }).join("\n");
+};
+
+/* -----[ Utilities ]----- */
+
+function repeat_string(str, i) {
+ if (i <= 0) return "";
+ if (i == 1) return str;
+ var d = repeat_string(str, i >> 1);
+ d += d;
+ if (i & 1) d += str;
+ return d;
+};
+
+function defaults(args, defs) {
+ var ret = {};
+ if (args === true)
+ args = {};
+ for (var i in defs) if (HOP(defs, i)) {
+ ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
+ }
+ return ret;
+};
+
+function is_identifier(name) {
+ return /^[a-z_$][a-z0-9_$]*$/i.test(name)
+ && name != "this"
+ && !HOP(jsp.KEYWORDS_ATOM, name)
+ && !HOP(jsp.RESERVED_WORDS, name)
+ && !HOP(jsp.KEYWORDS, name);
+};
+
+function HOP(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+// some utilities
+
+var MAP;
+
+(function(){
+ MAP = function(a, f, o) {
+ var ret = [];
+ for (var i = 0; i < a.length; ++i) {
+ var val = f.call(o, a[i], i);
+ if (val instanceof AtTop) ret.unshift(val.v);
+ else ret.push(val);
+ }
+ return ret;
+ };
+ MAP.at_top = function(val) { return new AtTop(val) };
+ function AtTop(val) { this.v = val };
+})();
+
+/* -----[ Exports ]----- */
+
+exports.ast_walker = ast_walker;
+exports.ast_mangle = ast_mangle;
+exports.ast_squeeze = ast_squeeze;
+exports.gen_code = gen_code;
+exports.ast_add_scope = ast_add_scope;
+exports.set_logger = function(logger) { warn = logger };
+exports.make_string = make_string;
+exports.split_lines = split_lines;
+exports.MAP = MAP;
+
+// keep this last!
+exports.ast_squeeze_more = require("./squeeze-more").ast_squeeze_more;
--- /dev/null
+var jsp = require("./parse-js"),
+ pro = require("./process"),
+ slice = jsp.slice,
+ member = jsp.member,
+ PRECEDENCE = jsp.PRECEDENCE,
+ OPERATORS = jsp.OPERATORS;
+
+function ast_squeeze_more(ast) {
+ var w = pro.ast_walker(), walk = w.walk;
+ return w.with_walkers({
+ "call": function(expr, args) {
+ if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+ // foo.toString() ==> foo+""
+ return [ "binary", "+", expr[1], [ "string", "" ]];
+ }
+ }
+ }, function() {
+ return walk(ast);
+ });
+};
+
+exports.ast_squeeze_more = ast_squeeze_more;
--- /dev/null
+{
+ "name" : "uglify-js",
+
+ "author" : {
+ "name" : "Mihai Bazon",
+ "email" : "mihai.bazon@gmail.com",
+ "url" : "http://mihai.bazon.net/blog"
+ },
+
+ "version" : "1.0.6",
+
+ "main" : "./uglify-js.js",
+
+ "bin" : {
+ "uglifyjs" : "./bin/uglifyjs"
+ },
+
+ "repository": {
+ "type": "git",
+ "url": "git@github.com:mishoo/UglifyJS.git"
+ }
+}
--- /dev/null
+#! /usr/bin/env node
+
+global.sys = require("sys");
+var fs = require("fs");
+
+var jsp = require("../lib/parse-js");
+var pro = require("../lib/process");
+
+var filename = process.argv[2];
+fs.readFile(filename, "utf8", function(err, text){
+ try {
+ var ast = time_it("parse", function(){ return jsp.parse(text); });
+ ast = time_it("mangle", function(){ return pro.ast_mangle(ast); });
+ ast = time_it("squeeze", function(){ return pro.ast_squeeze(ast); });
+ var gen = time_it("generate", function(){ return pro.gen_code(ast, false); });
+ sys.puts(gen);
+ } catch(ex) {
+ sys.debug(ex.stack);
+ sys.debug(sys.inspect(ex));
+ sys.debug(JSON.stringify(ex));
+ }
+});
+
+function time_it(name, cont) {
+ var t1 = new Date().getTime();
+ try { return cont(); }
+ finally { sys.debug("// " + name + ": " + ((new Date().getTime() - t1) / 1000).toFixed(3) + " sec."); }
+};
--- /dev/null
+#! /usr/bin/env node
+
+var parseJS = require("../lib/parse-js");
+var sys = require("sys");
+
+// write debug in a very straightforward manner
+var debug = function(){
+ sys.log(Array.prototype.slice.call(arguments).join(', '));
+};
+
+ParserTestSuite(function(i, input, desc){
+ try {
+ parseJS.parse(input);
+ debug("ok " + i + ": " + desc);
+ } catch(e){
+ debug("FAIL " + i + " " + desc + " (" + e + ")");
+ }
+});
+
+function ParserTestSuite(callback){
+ var inps = [
+ ["var abc;", "Regular variable statement w/o assignment"],
+ ["var abc = 5;", "Regular variable statement with assignment"],
+ ["/* */;", "Multiline comment"],
+ ['/** **/;', 'Double star multiline comment'],
+ ["var f = function(){;};", "Function expression in var assignment"],
+ ['hi; // moo\n;', 'single line comment'],
+ ['var varwithfunction;', 'Dont match keywords as substrings'], // difference between `var withsomevar` and `"str"` (local search and lits)
+ ['a + b;', 'addition'],
+ ["'a';", 'single string literal'],
+ ["'a\\n';", 'single string literal with escaped return'],
+ ['"a";', 'double string literal'],
+ ['"a\\n";', 'double string literal with escaped return'],
+ ['"var";', 'string is a keyword'],
+ ['"variable";', 'string starts with a keyword'],
+ ['"somevariable";', 'string contains a keyword'],
+ ['"somevar";', 'string ends with a keyword'],
+ ['500;', 'int literal'],
+ ['500.;', 'float literal w/o decimals'],
+ ['500.432;', 'float literal with decimals'],
+ ['.432432;', 'float literal w/o int'],
+ ['(a,b,c);', 'parens and comma'],
+ ['[1,2,abc];', 'array literal'],
+ ['var o = {a:1};', 'object literal unquoted key'],
+ ['var o = {"b":2};', 'object literal quoted key'], // opening curly may not be at the start of a statement...
+ ['var o = {c:c};', 'object literal keyname is identifier'],
+ ['var o = {a:1,"b":2,c:c};', 'object literal combinations'],
+ ['var x;\nvar y;', 'two lines'],
+ ['var x;\nfunction n(){; }', 'function def'],
+ ['var x;\nfunction n(abc){; }', 'function def with arg'],
+ ['var x;\nfunction n(abc, def){ ;}', 'function def with args'],
+ ['function n(){ "hello"; }', 'function def with body'],
+ ['/a/;', 'regex literal'],
+ ['/a/b;', 'regex literal with flag'],
+ ['/a/ / /b/;', 'regex div regex'],
+ ['a/b/c;', 'triple division looks like regex'],
+ ['+function(){/regex/;};', 'regex at start of function body'],
+ // http://code.google.com/p/es-lab/source/browse/trunk/tests/parser/parsertests.js?r=86
+ // http://code.google.com/p/es-lab/source/browse/trunk/tests/parser/parsertests.js?r=430
+
+ // first tests for the lexer, should also parse as program (when you append a semi)
+
+ // comments
+ ['//foo!@#^&$1234\nbar;', 'single line comment'],
+ ['/* abcd!@#@$* { } && null*/;', 'single line multi line comment'],
+ ['/*foo\nbar*/;','multi line comment'],
+ ['/*x*x*/;','multi line comment with *'],
+ ['/**/;','empty comment'],
+ // identifiers
+ ["x;",'1 identifier'],
+ ["_x;",'2 identifier'],
+ ["xyz;",'3 identifier'],
+ ["$x;",'4 identifier'],
+ ["x$;",'5 identifier'],
+ ["_;",'6 identifier'],
+ ["x5;",'7 identifier'],
+ ["x_y;",'8 identifier'],
+ ["x+5;",'9 identifier'],
+ ["xyz123;",'10 identifier'],
+ ["x1y1z1;",'11 identifier'],
+ ["foo\\u00D8bar;",'12 identifier unicode escape'],
+ //["foo�bar;",'13 identifier unicode embedded (might fail)'],
+ // numbers
+ ["5;", '1 number'],
+ ["5.5;", '2 number'],
+ ["0;", '3 number'],
+ ["0.0;", '4 number'],
+ ["0.001;", '5 number'],
+ ["1.e2;", '6 number'],
+ ["1.e-2;", '7 number'],
+ ["1.E2;", '8 number'],
+ ["1.E-2;", '9 number'],
+ [".5;", '10 number'],
+ [".5e3;", '11 number'],
+ [".5e-3;", '12 number'],
+ ["0.5e3;", '13 number'],
+ ["55;", '14 number'],
+ ["123;", '15 number'],
+ ["55.55;", '16 number'],
+ ["55.55e10;", '17 number'],
+ ["123.456;", '18 number'],
+ ["1+e;", '20 number'],
+ ["0x01;", '22 number'],
+ ["0XCAFE;", '23 number'],
+ ["0x12345678;", '24 number'],
+ ["0x1234ABCD;", '25 number'],
+ ["0x0001;", '26 number'],
+ // strings
+ ["\"foo\";", '1 string'],
+ ["\'foo\';", '2 string'],
+ ["\"x\";", '3 string'],
+ ["\'\';", '4 string'],
+ ["\"foo\\tbar\";", '5 string'],
+ ["\"!@#$%^&*()_+{}[]\";", '6 string'],
+ ["\"/*test*/\";", '7 string'],
+ ["\"//test\";", '8 string'],
+ ["\"\\\\\";", '9 string'],
+ ["\"\\u0001\";", '10 string'],
+ ["\"\\uFEFF\";", '11 string'],
+ ["\"\\u10002\";", '12 string'],
+ ["\"\\x55\";", '13 string'],
+ ["\"\\x55a\";", '14 string'],
+ ["\"a\\\\nb\";", '15 string'],
+ ['";"', '16 string: semi in a string'],
+ ['"a\\\nb";', '17 string: line terminator escape'],
+ // literals
+ ["null;", "null"],
+ ["true;", "true"],
+ ["false;", "false"],
+ // regex
+ ["/a/;", "1 regex"],
+ ["/abc/;", "2 regex"],
+ ["/abc[a-z]*def/g;", "3 regex"],
+ ["/\\b/;", "4 regex"],
+ ["/[a-zA-Z]/;", "5 regex"],
+
+ // program tests (for as far as they havent been covered above)
+
+ // regexp
+ ["/foo(.*)/g;", "another regexp"],
+ // arrays
+ ["[];", "1 array"],
+ ["[ ];", "2 array"],
+ ["[1];", "3 array"],
+ ["[1,2];", "4 array"],
+ ["[1,2,,];", "5 array"],
+ ["[1,2,3];", "6 array"],
+ ["[1,2,3,,,];", "7 array"],
+ // objects
+ ["{};", "1 object"],
+ ["({x:5});", "2 object"],
+ ["({x:5,y:6});", "3 object"],
+ ["({x:5,});", "4 object"],
+ ["({if:5});", "5 object"],
+ ["({ get x() {42;} });", "6 object"],
+ ["({ set y(a) {1;} });", "7 object"],
+ // member expression
+ ["o.m;", "1 member expression"],
+ ["o['m'];", "2 member expression"],
+ ["o['n']['m'];", "3 member expression"],
+ ["o.n.m;", "4 member expression"],
+ ["o.if;", "5 member expression"],
+ // call and invoke expressions
+ ["f();", "1 call/invoke expression"],
+ ["f(x);", "2 call/invoke expression"],
+ ["f(x,y);", "3 call/invoke expression"],
+ ["o.m();", "4 call/invoke expression"],
+ ["o['m'];", "5 call/invoke expression"],
+ ["o.m(x);", "6 call/invoke expression"],
+ ["o['m'](x);", "7 call/invoke expression"],
+ ["o.m(x,y);", "8 call/invoke expression"],
+ ["o['m'](x,y);", "9 call/invoke expression"],
+ ["f(x)(y);", "10 call/invoke expression"],
+ ["f().x;", "11 call/invoke expression"],
+
+ // eval
+ ["eval('x');", "1 eval"],
+ ["(eval)('x');", "2 eval"],
+ ["(1,eval)('x');", "3 eval"],
+ ["eval(x,y);", "4 eval"],
+ // new expression
+ ["new f();", "1 new expression"],
+ ["new o;", "2 new expression"],
+ ["new o.m;", "3 new expression"],
+ ["new o.m(x);", "4 new expression"],
+ ["new o.m(x,y);", "5 new expression"],
+ // prefix/postfix
+ ["++x;", "1 pre/postfix"],
+ ["x++;", "2 pre/postfix"],
+ ["--x;", "3 pre/postfix"],
+ ["x--;", "4 pre/postfix"],
+ ["x ++;", "5 pre/postfix"],
+ ["x /* comment */ ++;", "6 pre/postfix"],
+ ["++ /* comment */ x;", "7 pre/postfix"],
+ // unary operators
+ ["delete x;", "1 unary operator"],
+ ["void x;", "2 unary operator"],
+ ["+ x;", "3 unary operator"],
+ ["-x;", "4 unary operator"],
+ ["~x;", "5 unary operator"],
+ ["!x;", "6 unary operator"],
+ // meh
+ ["new Date++;", "new date ++"],
+ ["+x++;", " + x ++"],
+ // expression expressions
+ ["1 * 2;", "1 expression expressions"],
+ ["1 / 2;", "2 expression expressions"],
+ ["1 % 2;", "3 expression expressions"],
+ ["1 + 2;", "4 expression expressions"],
+ ["1 - 2;", "5 expression expressions"],
+ ["1 << 2;", "6 expression expressions"],
+ ["1 >>> 2;", "7 expression expressions"],
+ ["1 >> 2;", "8 expression expressions"],
+ ["1 * 2 + 3;", "9 expression expressions"],
+ ["(1+2)*3;", "10 expression expressions"],
+ ["1*(2+3);", "11 expression expressions"],
+ ["x<y;", "12 expression expressions"],
+ ["x>y;", "13 expression expressions"],
+ ["x<=y;", "14 expression expressions"],
+ ["x>=y;", "15 expression expressions"],
+ ["x instanceof y;", "16 expression expressions"],
+ ["x in y;", "17 expression expressions"],
+ ["x&y;", "18 expression expressions"],
+ ["x^y;", "19 expression expressions"],
+ ["x|y;", "20 expression expressions"],
+ ["x+y<z;", "21 expression expressions"],
+ ["x<y+z;", "22 expression expressions"],
+ ["x+y+z;", "23 expression expressions"],
+ ["x+y<z;", "24 expression expressions"],
+ ["x<y+z;", "25 expression expressions"],
+ ["x&y|z;", "26 expression expressions"],
+ ["x&&y;", "27 expression expressions"],
+ ["x||y;", "28 expression expressions"],
+ ["x&&y||z;", "29 expression expressions"],
+ ["x||y&&z;", "30 expression expressions"],
+ ["x<y?z:w;", "31 expression expressions"],
+ // assignment
+ ["x >>>= y;", "1 assignment"],
+ ["x <<= y;", "2 assignment"],
+ ["x = y;", "3 assignment"],
+ ["x += y;", "4 assignment"],
+ ["x /= y;", "5 assignment"],
+ // comma
+ ["x, y;", "comma"],
+ // block
+ ["{};", "1 block"],
+ ["{x;};", "2 block"],
+ ["{x;y;};", "3 block"],
+ // vars
+ ["var x;", "1 var"],
+ ["var x,y;", "2 var"],
+ ["var x=1,y=2;", "3 var"],
+ ["var x,y=2;", "4 var"],
+ // empty
+ [";", "1 empty"],
+ ["\n;", "2 empty"],
+ // expression statement
+ ["x;", "1 expression statement"],
+ ["5;", "2 expression statement"],
+ ["1+2;", "3 expression statement"],
+ // if
+ ["if (c) x; else y;", "1 if statement"],
+ ["if (c) x;", "2 if statement"],
+ ["if (c) {} else {};", "3 if statement"],
+ ["if (c1) if (c2) s1; else s2;", "4 if statement"],
+ // while
+ ["do s; while (e);", "1 while statement"],
+ ["do { s; } while (e);", "2 while statement"],
+ ["while (e) s;", "3 while statement"],
+ ["while (e) { s; };", "4 while statement"],
+ // for
+ ["for (;;) ;", "1 for statement"],
+ ["for (;c;x++) x;", "2 for statement"],
+ ["for (i;i<len;++i){};", "3 for statement"],
+ ["for (var i=0;i<len;++i) {};", "4 for statement"],
+ ["for (var i=0,j=0;;){};", "5 for statement"],
+ //["for (x in b; c; u) {};", "6 for statement"],
+ ["for ((x in b); c; u) {};", "7 for statement"],
+ ["for (x in a);", "8 for statement"],
+ ["for (var x in a){};", "9 for statement"],
+ ["for (var x=5 in a) {};", "10 for statement"],
+ ["for (var x = a in b in c) {};", "11 for statement"],
+ ["for (var x=function(){a+b;}; a<b; ++i) some;", "11 for statement, testing for parsingForHeader reset with the function"],
+ ["for (var x=function(){for (x=0; x<15; ++x) alert(foo); }; a<b; ++i) some;", "11 for statement, testing for parsingForHeader reset with the function"],
+ // flow statements
+ ["while(1){ continue; }", "1 flow statement"],
+ ["label: while(1){ continue label; }", "2 flow statement"],
+ ["while(1){ break; }", "3 flow statement"],
+ ["somewhere: while(1){ break somewhere; }", "4 flow statement"],
+ ["while(1){ continue /* comment */ ; }", "5 flow statement"],
+ ["while(1){ continue \n; }", "6 flow statement"],
+ ["(function(){ return; })()", "7 flow statement"],
+ ["(function(){ return 0; })()", "8 flow statement"],
+ ["(function(){ return 0 + \n 1; })()", "9 flow statement"],
+ // with
+ ["with (e) s;", "with statement"],
+ // switch
+ ["switch (e) { case x: s; };", "1 switch statement"],
+ ["switch (e) { case x: s1;s2; default: s3; case y: s4; };", "2 switch statement"],
+ ["switch (e) { default: s1; case x: s2; case y: s3; };", "3 switch statement"],
+ ["switch (e) { default: s; };", "4 switch statement"],
+ ["switch (e) { case x: s1; case y: s2; };", "5 switch statement"],
+ // labels
+ ["foo : x;", " flow statement"],
+ // throw
+ ["throw x;", "1 throw statement"],
+ ["throw x\n;", "2 throw statement"],
+ // try catch finally
+ ["try { s1; } catch (e) { s2; };", "1 trycatchfinally statement"],
+ ["try { s1; } finally { s2; };", "2 trycatchfinally statement"],
+ ["try { s1; } catch (e) { s2; } finally { s3; };", "3 trycatchfinally statement"],
+ // debugger
+ ["debugger;", "debuger statement"],
+ // function decl
+ ["function f(x) { e; return x; };", "1 function declaration"],
+ ["function f() { x; y; };", "2 function declaration"],
+ ["function f(x,y) { var z; return x; };", "3 function declaration"],
+ // function exp
+ ["(function f(x) { return x; });", "1 function expression"],
+ ["(function empty() {;});", "2 function expression"],
+ ["(function empty() {;});", "3 function expression"],
+ ["(function (x) {; });", "4 function expression"],
+ // program
+ ["var x; function f(){;}; null;", "1 program"],
+ [";;", "2 program"],
+ ["{ x; y; z; }", "3 program"],
+ ["function f(){ function g(){;}};", "4 program"],
+ ["x;\n/*foo*/\n ;", "5 program"],
+
+ // asi
+ ["foo: while(1){ continue \n foo; }", "1 asi"],
+ ["foo: while(1){ break \n foo; }", "2 asi"],
+ ["(function(){ return\nfoo; })()", "3 asi"],
+ ["var x; { 1 \n 2 } 3", "4 asi"],
+ ["ab /* hi */\ncd", "5 asi"],
+ ["ab/*\n*/cd", "6 asi (multi line multilinecomment counts as eol)"],
+ ["foo: while(1){ continue /* wtf \n busta */ foo; }", "7 asi illegal with multi line comment"],
+ ["function f() { s }", "8 asi"],
+ ["function f() { return }", "9 asi"],
+
+ // use strict
+ // XXX: some of these should actually fail?
+ // no support for "use strict" yet...
+ ['"use strict"; \'bla\'\n; foo;', "1 directive"],
+ ['(function() { "use strict"; \'bla\';\n foo; });', "2 directive"],
+ ['"use\\n strict";', "3 directive"],
+ ['foo; "use strict";', "4 directive"],
+
+ // tests from http://es5conform.codeplex.com/
+
+ ['"use strict"; var o = { eval: 42};', "8.7.2-3-1-s: the use of eval as property name is allowed"],
+ ['({foo:0,foo:1});', 'Duplicate property name allowed in not strict mode'],
+ ['function foo(a,a){}', 'Duplicate parameter name allowed in not strict mode'],
+ ['(function foo(eval){})', 'Eval allowed as parameter name in non strict mode'],
+ ['(function foo(arguments){})', 'Arguments allowed as parameter name in non strict mode'],
+
+ // empty programs
+
+ ['', '1 Empty program'],
+ ['// test', '2 Empty program'],
+ ['//test\n', '3 Empty program'],
+ ['\n// test', '4 Empty program'],
+ ['\n// test\n', '5 Empty program'],
+ ['/* */', '6 Empty program'],
+ ['/*\ns,fd\n*/', '7 Empty program'],
+ ['/*\ns,fd\n*/\n', '8 Empty program'],
+ [' ', '9 Empty program'],
+ [' /*\nsmeh*/ \n ', '10 Empty program'],
+
+ // trailing whitespace
+
+ ['a ', '1 Trailing whitespace'],
+ ['a /* something */', '2 Trailing whitespace'],
+ ['a\n // hah', '3 Trailing whitespace'],
+ ['/abc/de//f', '4 Trailing whitespace'],
+ ['/abc/de/*f*/\n ', '5 Trailing whitespace'],
+
+ // things the parser tripped over at one point or the other (prevents regression bugs)
+ ['for (x;function(){ a\nb };z) x;', 'for header with function body forcing ASI'],
+ ['c=function(){return;return};', 'resetting noAsi after literal'],
+ ['d\nd()', 'asi exception causing token overflow'],
+ ['for(;;){x=function(){}}', 'function expression in a for header'],
+ ['for(var k;;){}', 'parser failing due to ASI accepting the incorrect "for" rule'],
+ ['({get foo(){ }})', 'getter with empty function body'],
+ ['\nreturnr', 'eol causes return statement to ignore local search requirement'],
+ [' / /', '1 whitespace before regex causes regex to fail?'],
+ ['/ // / /', '2 whitespace before regex causes regex to fail?'],
+ ['/ / / / /', '3 whitespace before regex causes regex to fail?'],
+
+ ['\n\t// Used for trimming whitespace\n\ttrimLeft = /^\\s+/;\n\ttrimRight = /\\s+$/;\t\n','turned out this didnt crash (the test below did), but whatever.'],
+ ['/[\\/]/;', 'escaped forward slash inside class group (would choke on fwd slash)'],
+ ['/[/]/;', 'also broke but is valid in es5 (not es3)'],
+ ['({get:5});','get property name thats not a getter'],
+ ['({set:5});','set property name thats not a setter'],
+ ['l !== "px" && (d.style(h, c, (k || 1) + l), j = (k || 1) / f.cur() * j, d.style(h, c, j + l)), i[1] && (k = (i[1] === "-=" ? -1 : 1) * k + j), f.custom(j, k, l)', 'this choked regex/div at some point'],
+ ['(/\'/g, \'\\\\\\\'\') + "\'";', 'the sequence of escaped characters confused the tokenizer']
+ ];
+
+ for (var i=0; i<inps.length; ++i) {
+ callback(i, inps[i][0], inps[i][1]);
+ };
+};
--- /dev/null
+[],Array(1),[1,2,3]
--- /dev/null
+(function(){var a=function(){};return new a(1,2,3,4)})()
--- /dev/null
+(function(){function a(){}return new a(1,2,3,4)})()
--- /dev/null
+(function(){function a(){}(function(){return new a(1,2,3)})()})()
--- /dev/null
+a=1,b=a,c=1,d=b,e=d,longname=2;if(longname+1){x=3;if(x)var z=7}z=1,y=1,x=1,g+=1,h=g,++i,j=i,i++,j=i+17
\ No newline at end of file
--- /dev/null
+var a=a+"a"+"b"+1+c,b=a+"c"+"ds"+123+c,c=a+"c"+123+d+"ds"+c
\ No newline at end of file
--- /dev/null
+var a=13,b=1/3
\ No newline at end of file
--- /dev/null
+function mak(){for(;;);}function foo(){while(bar());}function bar(){return--x}var x=5
--- /dev/null
+a=func(),b=z;for(a++;i<10;i++)alert(i);var z=1;g=2;for(;i<10;i++)alert(i);var a=2;for(var i=1;i<10;i++)alert(i)
\ No newline at end of file
--- /dev/null
+var a=1;a==1?a=2:a=17
\ No newline at end of file
--- /dev/null
+function a(a){return a==1?2:17}
\ No newline at end of file
--- /dev/null
+function y(a){return typeof a=="object"?a:null}function x(a){return typeof a=="object"?a:a===42?0:a*2}
--- /dev/null
+function f(){var a;return(a="a")?a:a}f()
\ No newline at end of file
--- /dev/null
+new(A,B),new(A||B),new(X?A:B)
\ No newline at end of file
--- /dev/null
+var a=/^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#])(?::(\d))?)?(..?$|(?:[^?#\/]\/))([^?#]*)(?:\?([^#]))?(?:#(.))?/
\ No newline at end of file
--- /dev/null
+var a={"\b":"\\b","\t":"\\t","\n":"\\n","\f":"\\f","\r":"\\r",'"':'\\"',"\\":"\\\\"}
--- /dev/null
+var a=3250441966
\ No newline at end of file
--- /dev/null
+var a=function(b){b(),a()}
\ No newline at end of file
--- /dev/null
+a:1
\ No newline at end of file
--- /dev/null
+var a=0;switch(a){case 0:a++}
\ No newline at end of file
--- /dev/null
+label1:{label2:break label2;console.log(1)}
\ No newline at end of file
--- /dev/null
+(a?b:c)?d:e
\ No newline at end of file
--- /dev/null
+o={".5":.5},o={.5:.5},o={.5:.5}
\ No newline at end of file
--- /dev/null
+result=function(){return 1}()
\ No newline at end of file
--- /dev/null
+var a=8,b=4,c=4
\ No newline at end of file
--- /dev/null
+var a={};a["this"]=1,a.that=2
\ No newline at end of file
--- /dev/null
+var a=2e3,b=.002,c=2e-5
\ No newline at end of file
--- /dev/null
+var s,i;s="",i=0
\ No newline at end of file
--- /dev/null
+function bar(a){try{foo()}catch(b){alert("Exception caught (foo not defined)")}alert(a)}bar(10)
--- /dev/null
+foo+"",a.toString(16),b.toString.call(c)
--- /dev/null
+function f(){function b(){}a||b()}
--- /dev/null
+var a={a:1,b:2}
\ No newline at end of file
--- /dev/null
+(function(){var a=function b(a,b,c){return b}})()
--- /dev/null
+typeof a=="string",b+""!=c+"",d<e==f<g
\ No newline at end of file
--- /dev/null
+var a=1,b=2
\ No newline at end of file
--- /dev/null
+new Array();
+new Array(1);
+new Array(1, 2, 3);
--- /dev/null
+(function(){
+ var Array = function(){};
+ return new Array(1, 2, 3, 4);
+})();
--- /dev/null
+(function(){
+ return new Array(1, 2, 3, 4);
+ function Array() {};
+})();
--- /dev/null
+(function(){
+ (function(){
+ return new Array(1, 2, 3);
+ })();
+ function Array(){};
+})();
--- /dev/null
+a=1;
+b=a;
+c=1;
+d=b;
+e=d;
+longname=2;
+if (longname+1) {
+ x=3;
+ if (x) var z = 7;
+}
+z=1,y=1,x=1
+
+g+=1;
+h=g;
+
+++i;
+j=i;
+
+i++;
+j=i+17;
\ No newline at end of file
--- /dev/null
+var a = a + "a" + "b" + 1 + c;
+var b = a + "c" + "ds" + 123 + c;
+var c = a + "c" + 123 + d + "ds" + c;
\ No newline at end of file
--- /dev/null
+// test that the calculation is fold to 13\r
+var a = 1 + 2 * 6;\r
+\r
+// test that it isn't replaced with 0.3333 because that is more characters\r
+var b = 1/3;
\ No newline at end of file
--- /dev/null
+var x = 5;
+function bar() { return --x; }
+function foo() { while (bar()); }
+function mak() { for(;;); }
--- /dev/null
+a=func();
+b=z;
+for (a++; i < 10; i++) { alert(i); }
+
+var z=1;
+g=2;
+for (; i < 10; i++) { alert(i); }
+
+var a = 2;
+for (var i = 1; i < 10; i++) { alert(i); }
--- /dev/null
+var a = 1;\r
+if (a == 1) {\r
+ a = 2;\r
+} else {\r
+ a = 17;\r
+}\r
--- /dev/null
+function a(b) {\r
+ if (b == 1) {\r
+ return 2;\r
+ } else {\r
+ return 17;\r
+ }\r
+\r
+ return 3;\r
+}
\ No newline at end of file
--- /dev/null
+function x(a) {
+ if (typeof a === 'object')
+ return a;
+
+ if (a === 42)
+ return 0;
+
+ return a * 2;
+}
+
+function y(a) {
+ if (typeof a === 'object')
+ return a;
+
+ return null;
+};
--- /dev/null
+function f() { var a; if (a = 'a') { return a; } else { return a; } }; f();
\ No newline at end of file
--- /dev/null
+new (A, B)
+new (A || B)
+new (X ? A : B)
\ No newline at end of file
--- /dev/null
+var a = /^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#])(?::(\d))?)?(..?$|(?:[^?#\/]\/))([^?#]*)(?:\?([^#]))?(?:#(.))?/;
\ No newline at end of file
--- /dev/null
+var a = {'\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '\\': '\\\\'};
\ No newline at end of file
--- /dev/null
+var a = 0xC1BDCEEE;
\ No newline at end of file
--- /dev/null
+var a = function(b) {
+ b();
+ a()
+}
--- /dev/null
+{a: 1}
\ No newline at end of file
--- /dev/null
+var a = 0;
+switch(a) {
+ case 0:
+ a++;
+ break;
+}
\ No newline at end of file
--- /dev/null
+label1 : {
+ label2 : {
+ break label2;
+ console.log(2);
+ }
+ console.log(1);
+}
\ No newline at end of file
--- /dev/null
+(a ? b : c) ? d : e
\ No newline at end of file
--- /dev/null
+o = {'.5':.5}
+o = {'0.5':.5}
+o = {0.5:.5}
\ No newline at end of file
--- /dev/null
+result=(function(){ return 1;})()
\ No newline at end of file
--- /dev/null
+var a = 1 << 3;
+var b = 8 >> 1;
+var c = 8 >>> 1;
\ No newline at end of file
--- /dev/null
+var a = {};
+a["this"] = 1;
+a["that"] = 2;
\ No newline at end of file
--- /dev/null
+var a = 2e3;
+var b = 2e-3;
+var c = 2e-5;
\ No newline at end of file
--- /dev/null
+var s, i; s = ''; i = 0;
\ No newline at end of file
--- /dev/null
+function bar(a) {
+ try {
+ foo();
+ } catch(e) {
+ alert("Exception caught (foo not defined)");
+ }
+ alert(a); // 10 in FF, "[object Error]" in IE
+}
+bar(10);
--- /dev/null
+x = (y, z)
--- /dev/null
+foo.toString();
+a.toString(16);
+b.toString.call(c);
--- /dev/null
+function f() {
+ if (a) return;
+ g();
+ function g(){}
+};
--- /dev/null
+var a = {
+ a: 1,
+ b: 2, // <-- trailing comma
+};
--- /dev/null
+(function() {
+ var x = function fun(a, fun, b) {
+ return fun;
+ };
+}());
--- /dev/null
+typeof a === 'string'
+b + "" !== c + ""
+d < e === f < g
--- /dev/null
+// var declarations after each other should be combined\r
+var a = 1;\r
+var b = 2;
\ No newline at end of file
--- /dev/null
+with({}) {
+};
--- /dev/null
+var fs = require('fs'),
+ uglify = require('uglify-js'),
+ jsp = uglify.parser,
+ nodeunit = require('nodeunit'),
+ path = require('path'),
+ pro = uglify.uglify;
+
+var Script = process.binding('evals').Script;
+
+var scriptsPath = __dirname;
+
+function compress(code) {
+ var ast = jsp.parse(code);
+ ast = pro.ast_mangle(ast);
+ ast = pro.ast_squeeze(ast, {no_warnings: true, extra: true});
+ ast = pro.ast_squeeze_more(ast);
+ return pro.gen_code(ast);
+};
+
+var testDir = path.join(scriptsPath, "compress", "test");
+var expectedDir = path.join(scriptsPath, "compress", "expected");
+
+function getTester(script) {
+ return function(test) {
+ var testPath = path.join(testDir, script);
+ var expectedPath = path.join(expectedDir, script);
+ var content = fs.readFileSync(testPath, 'utf-8');
+ var outputCompress = compress(content);
+
+ // Check if the noncompressdata is larger or same size as the compressed data
+ test.ok(content.length >= outputCompress.length);
+
+ // Check that a recompress gives the same result
+ var outputReCompress = compress(content);
+ test.equal(outputCompress, outputReCompress);
+
+ // Check if the compressed output is what is expected
+ var expected = fs.readFileSync(expectedPath, 'utf-8');
+ test.equal(outputCompress, expected.replace(/(\r?\n)+$/, ""));
+
+ test.done();
+ };
+};
+
+var tests = {};
+
+var scripts = fs.readdirSync(testDir);
+for (var i in scripts) {
+ var script = scripts[i];
+ if (/\.js$/.test(script)) {
+ tests[script] = getTester(script);
+ }
+}
+
+module.exports = nodeunit.testCase(tests);
--- /dev/null
+// sample on how to use the parser and walker API to instrument some code
+
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+function instrument(code) {
+ var ast = jsp.parse(code, false, true); // true for the third arg specifies that we want
+ // to have start/end tokens embedded in the
+ // statements
+ var w = pro.ast_walker();
+
+ // we're gonna need this to push elements that we're currently looking at, to avoid
+ // endless recursion.
+ var analyzing = [];
+ function do_stat() {
+ var ret;
+ if (this[0].start && analyzing.indexOf(this) < 0) {
+ // without the `analyzing' hack, w.walk(this) would re-enter here leading
+ // to infinite recursion
+ analyzing.push(this);
+ ret = [ "splice", // XXX: "block" is safer
+ [ [ "stat",
+ [ "call", [ "name", "trace" ],
+ [ [ "string", this[0].toString() ],
+ [ "num", this[0].start.line ],
+ [ "num", this[0].start.col ],
+ [ "num", this[0].end.line ],
+ [ "num", this[0].end.col ]]]],
+ w.walk(this) ]];
+ analyzing.pop(this);
+ }
+ return ret;
+ };
+ var new_ast = w.with_walkers({
+ "stat" : do_stat,
+ "label" : do_stat,
+ "break" : do_stat,
+ "continue" : do_stat,
+ "debugger" : do_stat,
+ "var" : do_stat,
+ "const" : do_stat,
+ "return" : do_stat,
+ "throw" : do_stat,
+ "try" : do_stat,
+ "defun" : do_stat,
+ "if" : do_stat,
+ "while" : do_stat,
+ "do" : do_stat,
+ "for" : do_stat,
+ "for-in" : do_stat,
+ "switch" : do_stat,
+ "with" : do_stat
+ }, function(){
+ return w.walk(ast);
+ });
+ return pro.gen_code(new_ast, { beautify: true });
+}
+
+
+
+
+////// test code follows.
+
+var code = instrument(test.toString());
+console.log(code);
+
+function test() {
+ // simple stats
+ a = 5;
+ c += a + b;
+ "foo";
+
+ // var
+ var foo = 5;
+ const bar = 6, baz = 7;
+
+ // switch block. note we can't track case lines the same way.
+ switch ("foo") {
+ case "foo":
+ return 1;
+ case "bar":
+ return 2;
+ }
+
+ // for/for in
+ for (var i = 0; i < 5; ++i) {
+ console.log("Hello " + i);
+ }
+ for (var i in [ 1, 2, 3]) {
+ console.log(i);
+ }
+
+ // note however that the following is broken. I guess we
+ // should add the block brackets in this case...
+ for (var i = 0; i < 5; ++i)
+ console.log("foo");
+}
--- /dev/null
+// sample on how to use the parser and walker API to instrument some code
+
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+function instrument(code) {
+ var ast = jsp.parse(code, false, true); // true for the third arg specifies that we want
+ // to have start/end tokens embedded in the
+ // statements
+ var w = pro.ast_walker();
+
+ function trace (line, comment) {
+ var code = pro.gen_code(line, { beautify: true });
+ var data = line[0]
+
+ var args = []
+ if (!comment) comment = ""
+ if (typeof data === "object") {
+ code = code.split(/\n/).shift()
+ args = [ [ "string", data.toString() ],
+ [ "string", code ],
+ [ "num", data.start.line ],
+ [ "num", data.start.col ],
+ [ "num", data.end.line ],
+ [ "num", data.end.col ]]
+ } else {
+ args = [ [ "string", data ],
+ [ "string", code ]]
+
+ }
+ return [ "call", [ "name", "trace" ], args ];
+ }
+
+ // we're gonna need this to push elements that we're currently looking at, to avoid
+ // endless recursion.
+ var analyzing = [];
+ function do_stat() {
+ var ret;
+ if (this[0].start && analyzing.indexOf(this) < 0) {
+ // without the `analyzing' hack, w.walk(this) would re-enter here leading
+ // to infinite recursion
+ analyzing.push(this);
+ ret = [ "splice",
+ [ [ "stat", trace(this) ],
+ w.walk(this) ]];
+ analyzing.pop(this);
+ }
+ return ret;
+ }
+
+ function do_cond(c, t, f) {
+ return [ this[0], w.walk(c),
+ ["seq", trace(t), w.walk(t) ],
+ ["seq", trace(f), w.walk(f) ]];
+ }
+
+ function do_binary(c, l, r) {
+ if (c !== "&&" && c !== "||") {
+ return [this[0], c, w.walk(l), w.walk(r)];
+ }
+ return [ this[0], c,
+ ["seq", trace(l), w.walk(l) ],
+ ["seq", trace(r), w.walk(r) ]];
+ }
+
+ var new_ast = w.with_walkers({
+ "stat" : do_stat,
+ "label" : do_stat,
+ "break" : do_stat,
+ "continue" : do_stat,
+ "debugger" : do_stat,
+ "var" : do_stat,
+ "const" : do_stat,
+ "return" : do_stat,
+ "throw" : do_stat,
+ "try" : do_stat,
+ "defun" : do_stat,
+ "if" : do_stat,
+ "while" : do_stat,
+ "do" : do_stat,
+ "for" : do_stat,
+ "for-in" : do_stat,
+ "switch" : do_stat,
+ "with" : do_stat,
+ "conditional" : do_cond,
+ "binary" : do_binary
+ }, function(){
+ return w.walk(ast);
+ });
+ return pro.gen_code(new_ast, { beautify: true });
+}
+
+
+////// test code follows.
+
+var code = instrument(test.toString());
+console.log(code);
+
+function test() {
+ // simple stats
+ a = 5;
+ c += a + b;
+ "foo";
+
+ // var
+ var foo = 5;
+ const bar = 6, baz = 7;
+
+ // switch block. note we can't track case lines the same way.
+ switch ("foo") {
+ case "foo":
+ return 1;
+ case "bar":
+ return 2;
+ }
+
+ // for/for in
+ for (var i = 0; i < 5; ++i) {
+ console.log("Hello " + i);
+ }
+ for (var i in [ 1, 2, 3]) {
+ console.log(i);
+ }
+
+ for (var i = 0; i < 5; ++i)
+ console.log("foo");
+
+ for (var i = 0; i < 5; ++i) {
+ console.log("foo");
+ }
+
+ var k = plurp() ? 1 : 0;
+ var x = a ? doX(y) && goZoo("zoo")
+ : b ? blerg({ x: y })
+ : null;
+
+ var x = X || Y;
+}
--- /dev/null
+//convienence function(src, [options]);
+function uglify(orig_code, options){
+ options || (options = {});
+ var jsp = uglify.parser;
+ var pro = uglify.uglify;
+
+ var ast = jsp.parse(orig_code, options.strict_semicolons); // parse code and get the initial AST
+ ast = pro.ast_mangle(ast, options.mangle_options); // get a new AST with mangled names
+ ast = pro.ast_squeeze(ast, options.squeeze_options); // get an AST with compression optimizations
+ var final_code = pro.gen_code(ast, options.gen_options); // compressed code here
+ return final_code;
+};
+
+uglify.parser = require("./lib/parse-js");
+uglify.uglify = require("./lib/process");
+
+module.exports = uglify
\ No newline at end of file
--- /dev/null
+.DS_Store
+.tmp*~
+*.local.*
+.pinf-*
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"
+lang="en" xml:lang="en">
+<head>
+<title>UglifyJS -- a JavaScript parser/compressor/beautifier</title>
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
+<meta name="generator" content="Org-mode"/>
+<meta name="generated" content="2011-07-14 12:50:31 EEST"/>
+<meta name="author" content="Mihai Bazon"/>
+<meta name="description" content="a JavaScript parser/compressor/beautifier in JavaScript"/>
+<meta name="keywords" content="javascript, js, parser, compiler, compressor, mangle, minify, minifier"/>
+<style type="text/css">
+ <!--/*--><![CDATA[/*><!--*/
+ html { font-family: Times, serif; font-size: 12pt; }
+ .title { text-align: center; }
+ .todo { color: red; }
+ .done { color: green; }
+ .tag { background-color: #add8e6; font-weight:normal }
+ .target { }
+ .timestamp { color: #bebebe; }
+ .timestamp-kwd { color: #5f9ea0; }
+ p.verse { margin-left: 3% }
+ pre {
+ border: 1pt solid #AEBDCC;
+ background-color: #F3F5F7;
+ padding: 5pt;
+ font-family: courier, monospace;
+ font-size: 90%;
+ overflow:auto;
+ }
+ table { border-collapse: collapse; }
+ td, th { vertical-align: top; }
+ dt { font-weight: bold; }
+ div.figure { padding: 0.5em; }
+ div.figure p { text-align: center; }
+ textarea { overflow-x: auto; }
+ .linenr { font-size:smaller }
+ .code-highlighted {background-color:#ffff00;}
+ .org-info-js_info-navigation { border-style:none; }
+ #org-info-js_console-label { font-size:10px; font-weight:bold;
+ white-space:nowrap; }
+ .org-info-js_search-highlight {background-color:#ffff00; color:#000000;
+ font-weight:bold; }
+ /*]]>*/-->
+</style>
+<link rel="stylesheet" type="text/css" href="docstyle.css" />
+<script type="text/javascript">
+<!--/*--><![CDATA[/*><!--*/
+ function CodeHighlightOn(elem, id)
+ {
+ var target = document.getElementById(id);
+ if(null != target) {
+ elem.cacheClassElem = elem.className;
+ elem.cacheClassTarget = target.className;
+ target.className = "code-highlighted";
+ elem.className = "code-highlighted";
+ }
+ }
+ function CodeHighlightOff(elem, id)
+ {
+ var target = document.getElementById(id);
+ if(elem.cacheClassElem)
+ elem.className = elem.cacheClassElem;
+ if(elem.cacheClassTarget)
+ target.className = elem.cacheClassTarget;
+ }
+/*]]>*///-->
+</script>
+
+</head>
+<body>
+<div id="content">
+
+<h1 class="title">UglifyJS – a JavaScript parser/compressor/beautifier</h1>
+
+
+<div id="table-of-contents">
+<h2>Table of Contents</h2>
+<div id="text-table-of-contents">
+<ul>
+<li><a href="#sec-1">1 UglifyJS — a JavaScript parser/compressor/beautifier </a>
+<ul>
+<li><a href="#sec-1_1">1.1 Unsafe transformations </a>
+<ul>
+<li><a href="#sec-1_1_1">1.1.1 Calls involving the global Array constructor </a></li>
+</ul>
+</li>
+<li><a href="#sec-1_2">1.2 Install (NPM) </a></li>
+<li><a href="#sec-1_3">1.3 Install latest code from GitHub </a></li>
+<li><a href="#sec-1_4">1.4 Usage </a>
+<ul>
+<li><a href="#sec-1_4_1">1.4.1 API </a></li>
+<li><a href="#sec-1_4_2">1.4.2 Beautifier shortcoming – no more comments </a></li>
+</ul>
+</li>
+<li><a href="#sec-1_5">1.5 Compression – how good is it? </a></li>
+<li><a href="#sec-1_6">1.6 Bugs? </a></li>
+<li><a href="#sec-1_7">1.7 Links </a></li>
+<li><a href="#sec-1_8">1.8 License </a></li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+
+<div id="outline-container-1" class="outline-2">
+<h2 id="sec-1"><span class="section-number-2">1</span> UglifyJS — a JavaScript parser/compressor/beautifier </h2>
+<div class="outline-text-2" id="text-1">
+
+
+<p>
+This package implements a general-purpose JavaScript
+parser/compressor/beautifier toolkit. It is developed on <a href="http://nodejs.org/">NodeJS</a>, but it
+should work on any JavaScript platform supporting the CommonJS module system
+(and if your platform of choice doesn't support CommonJS, you can easily
+implement it, or discard the <code>exports.*</code> lines from UglifyJS sources).
+</p>
+<p>
+The tokenizer/parser generates an abstract syntax tree from JS code. You
+can then traverse the AST to learn more about the code, or do various
+manipulations on it. This part is implemented in <a href="../lib/parse-js.js">parse-js.js</a> and it's a
+port to JavaScript of the excellent <a href="http://marijn.haverbeke.nl/parse-js/">parse-js</a> Common Lisp library from <a href="http://marijn.haverbeke.nl/">Marijn Haverbeke</a>.
+</p>
+<p>
+( See <a href="http://github.com/mishoo/cl-uglify-js">cl-uglify-js</a> if you're looking for the Common Lisp version of
+UglifyJS. )
+</p>
+<p>
+The second part of this package, implemented in <a href="../lib/process.js">process.js</a>, inspects and
+manipulates the AST generated by the parser to provide the following:
+</p>
+<ul>
+<li>
+ability to re-generate JavaScript code from the AST. Optionally
+indented—you can use this if you want to “beautify” a program that has
+been compressed, so that you can inspect the source. But you can also run
+our code generator to print out an AST without any whitespace, so you
+achieve compression as well.
+
+</li>
+<li>
+shorten variable names (usually to single characters). Our mangler will
+analyze the code and generate proper variable names, depending on scope
+and usage, and is smart enough to deal with globals defined elsewhere, or
+with <code>eval()</code> calls or <code>with{}</code> statements. In short, if <code>eval()</code> or
+<code>with{}</code> are used in some scope, then all variables in that scope and any
+variables in the parent scopes will remain unmangled, and any references
+to such variables remain unmangled as well.
+
+</li>
+<li>
+various small optimizations that may lead to faster code but certainly
+lead to smaller code. Where possible, we do the following:
+
+<ul>
+<li>
+foo["bar"] ==> foo.bar
+
+</li>
+<li>
+remove block brackets <code>{}</code>
+
+</li>
+<li>
+join consecutive var declarations:
+var a = 10; var b = 20; ==> var a=10,b=20;
+
+</li>
+<li>
+resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the
+replacement if the result occupies less bytes; for example 1/3 would
+translate to 0.333333333333, so in this case we don't replace it.
+
+</li>
+<li>
+consecutive statements in blocks are merged into a sequence; in many
+cases, this leaves blocks with a single statement, so then we can remove
+the block brackets.
+
+</li>
+<li>
+various optimizations for IF statements:
+
+<ul>
+<li>
+if (foo) bar(); else baz(); ==> foo?bar():baz();
+</li>
+<li>
+if (!foo) bar(); else baz(); ==> foo?baz():bar();
+</li>
+<li>
+if (foo) bar(); ==> foo&&bar();
+</li>
+<li>
+if (!foo) bar(); ==> foo||bar();
+</li>
+<li>
+if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
+</li>
+<li>
+if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+
+</li>
+</ul>
+</li>
+<li>
+remove some unreachable code and warn about it (code that follows a
+<code>return</code>, <code>throw</code>, <code>break</code> or <code>continue</code> statement, except
+function/variable declarations).
+</li>
+</ul>
+</li>
+</ul>
+
+
+
+</div>
+
+<div id="outline-container-1_1" class="outline-3">
+<h3 id="sec-1_1"><span class="section-number-3">1.1</span> <span class="target">Unsafe transformations</span> </h3>
+<div class="outline-text-3" id="text-1_1">
+
+
+<p>
+UglifyJS tries its best to achieve great compression while leaving the
+semantics of the code intact. In general, if your code logic is broken by
+UglifyJS then it's a bug in UglifyJS and you should report it and I should
+fix it. :-)
+</p>
+<p>
+However, I opted to include the following potentially unsafe transformations
+as default behavior. Discussion is welcome, if you have ideas of how to
+handle this better, or any objections to these optimizations, please let me
+know.
+</p>
+
+</div>
+
+<div id="outline-container-1_1_1" class="outline-4">
+<h4 id="sec-1_1_1"><span class="section-number-4">1.1.1</span> Calls involving the global Array constructor </h4>
+<div class="outline-text-4" id="text-1_1_1">
+
+
+<p>
+The following transformations occur:
+</p>
+
+
+
+<pre class="src src-js"><span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3, 4) => [1,2,3,4]
+Array(a, b, c) => [a,b,c]
+<span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(5) => Array(5)
+<span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(a) => Array(a)
+</pre>
+
+
+
+<p>
+These are all safe if the Array name isn't redefined. JavaScript does allow
+one to globally redefine Array (and pretty much everything, in fact) but I
+personally don't see why would anyone do that.
+</p>
+<p>
+UglifyJS does handle the case where Array is redefined locally, or even
+globally but with a <code>function</code> or <code>var</code> declaration. Therefore, in the
+following cases UglifyJS <b>doesn't touch</b> calls or instantiations of Array:
+</p>
+
+
+
+<pre class="src src-js"><span style="color: #00008b;">// </span><span style="color: #00008b;">case 1. globally declared variable
+</span> <span style="color: #8b0000;">var</span> <span style="color: #8b008b;">Array</span>;
+ <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ Array(a, b);
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or (can be declared later)
+</span> <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ <span style="color: #8b0000;">var</span> <span style="color: #8b008b;">Array</span>;
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or (can be a function)
+</span> <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ <span style="color: #8b0000;">function</span> <span style="color: #8b2323;">Array</span>() { ... }
+
+<span style="color: #00008b;">// </span><span style="color: #00008b;">case 2. declared in a function
+</span> (<span style="color: #8b0000;">function</span>(){
+ a = <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3);
+ b = Array(5, 6);
+ <span style="color: #8b0000;">var</span> <span style="color: #8b008b;">Array</span>;
+ })();
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or
+</span> (<span style="color: #8b0000;">function</span>(<span style="color: #8b008b;">Array</span>){
+ <span style="color: #8b0000;">return</span> Array(5, 6, 7);
+ })();
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">or
+</span> (<span style="color: #8b0000;">function</span>(){
+ <span style="color: #8b0000;">return</span> <span style="color: #8b0000;">new</span> <span style="color: #4682b4;">Array</span>(1, 2, 3, 4);
+ <span style="color: #8b0000;">function</span> <span style="color: #8b2323;">Array</span>() { ... }
+ })();
+
+ <span style="color: #00008b;">// </span><span style="color: #00008b;">etc.
+</span></pre>
+
+
+
+</div>
+</div>
+
+</div>
+
+<div id="outline-container-1_2" class="outline-3">
+<h3 id="sec-1_2"><span class="section-number-3">1.2</span> Install (NPM) </h3>
+<div class="outline-text-3" id="text-1_2">
+
+
+<p>
+UglifyJS is now available through NPM — <code>npm install uglify-js</code> should do
+the job.
+</p>
+</div>
+
+</div>
+
+<div id="outline-container-1_3" class="outline-3">
+<h3 id="sec-1_3"><span class="section-number-3">1.3</span> Install latest code from GitHub </h3>
+<div class="outline-text-3" id="text-1_3">
+
+
+
+
+
+<pre class="src src-sh"><span style="color: #00008b;">## </span><span style="color: #00008b;">clone the repository
+</span>mkdir -p /where/you/wanna/put/it
+<span style="color: #cd0000;">cd</span> /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+<span style="color: #00008b;">## </span><span style="color: #00008b;">make the module available to Node
+</span>mkdir -p ~/.node_libraries/
+<span style="color: #cd0000;">cd</span> ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+<span style="color: #00008b;">## </span><span style="color: #00008b;">and if you want the CLI script too:
+</span>mkdir -p ~/bin
+<span style="color: #cd0000;">cd</span> ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ <span style="color: #00008b;"># </span><span style="color: #00008b;">(then add ~/bin to your $PATH if it's not there already)
+</span></pre>
+
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1_4" class="outline-3">
+<h3 id="sec-1_4"><span class="section-number-3">1.4</span> Usage </h3>
+<div class="outline-text-3" id="text-1_4">
+
+
+<p>
+There is a command-line tool that exposes the functionality of this library
+for your shell-scripting needs:
+</p>
+
+
+
+<pre class="src src-sh">uglifyjs [ options... ] [ filename ]
+</pre>
+
+
+
+<p>
+<code>filename</code> should be the last argument and should name the file from which
+to read the JavaScript code. If you don't specify it, it will read code
+from STDIN.
+</p>
+<p>
+Supported options:
+</p>
+<ul>
+<li>
+<code>-b</code> or <code>--beautify</code> — output indented code; when passed, additional
+options control the beautifier:
+
+<ul>
+<li>
+<code>-i N</code> or <code>--indent N</code> — indentation level (number of spaces)
+
+</li>
+<li>
+<code>-q</code> or <code>--quote-keys</code> — quote keys in literal objects (by default,
+only keys that cannot be identifier names will be quotes).
+
+</li>
+</ul>
+</li>
+<li>
+<code>--ascii</code> — pass this argument to encode non-ASCII characters as
+<code>\uXXXX</code> sequences. By default UglifyJS won't bother to do it and will
+output Unicode characters instead. (the output is always encoded in UTF8,
+but if you pass this option you'll only get ASCII).
+
+</li>
+<li>
+<code>-nm</code> or <code>--no-mangle</code> — don't mangle variable names
+
+</li>
+<li>
+<code>-ns</code> or <code>--no-squeeze</code> — don't call <code>ast_squeeze()</code> (which does various
+optimizations that result in smaller, less readable code).
+
+</li>
+<li>
+<code>-mt</code> or <code>--mangle-toplevel</code> — mangle names in the toplevel scope too
+(by default we don't do this).
+
+</li>
+<li>
+<code>--no-seqs</code> — when <code>ast_squeeze()</code> is called (thus, unless you pass
+<code>--no-squeeze</code>) it will reduce consecutive statements in blocks into a
+sequence. For example, "a = 10; b = 20; foo();" will be written as
+"a=10,b=20,foo();". In various occasions, this allows us to discard the
+block brackets (since the block becomes a single statement). This is ON
+by default because it seems safe and saves a few hundred bytes on some
+libs that I tested it on, but pass <code>--no-seqs</code> to disable it.
+
+</li>
+<li>
+<code>--no-dead-code</code> — by default, UglifyJS will remove code that is
+obviously unreachable (code that follows a <code>return</code>, <code>throw</code>, <code>break</code> or
+<code>continue</code> statement and is not a function/variable declaration). Pass
+this option to disable this optimization.
+
+</li>
+<li>
+<code>-nc</code> or <code>--no-copyright</code> — by default, <code>uglifyjs</code> will keep the initial
+comment tokens in the generated code (assumed to be copyright information
+etc.). If you pass this it will discard it.
+
+</li>
+<li>
+<code>-o filename</code> or <code>--output filename</code> — put the result in <code>filename</code>. If
+this isn't given, the result goes to standard output (or see next one).
+
+</li>
+<li>
+<code>--overwrite</code> — if the code is read from a file (not from STDIN) and you
+pass <code>--overwrite</code> then the output will be written in the same file.
+
+</li>
+<li>
+<code>--ast</code> — pass this if you want to get the Abstract Syntax Tree instead
+of JavaScript as output. Useful for debugging or learning more about the
+internals.
+
+</li>
+<li>
+<code>-v</code> or <code>--verbose</code> — output some notes on STDERR (for now just how long
+each operation takes).
+
+</li>
+<li>
+<code>--extra</code> — enable additional optimizations that have not yet been
+extensively tested. These might, or might not, break your code. If you
+find a bug using this option, please report a test case.
+
+</li>
+<li>
+<code>--unsafe</code> — enable other additional optimizations that are known to be
+unsafe in some contrived situations, but could still be generally useful.
+For now only this:
+
+<ul>
+<li>
+foo.toString() ==> foo+""
+
+</li>
+</ul>
+</li>
+<li>
+<code>--max-line-len</code> (default 32K characters) — add a newline after around
+32K characters. I've seen both FF and Chrome croak when all the code was
+on a single line of around 670K. Pass –max-line-len 0 to disable this
+safety feature.
+
+</li>
+<li>
+<code>--reserved-names</code> — some libraries rely on certain names to be used, as
+pointed out in issue #92 and #81, so this option allow you to exclude such
+names from the mangler. For example, to keep names <code>require</code> and <code>$super</code>
+intact you'd specify –reserved-names "require,$super".
+
+</li>
+<li>
+<code>--inline-script</code> – when you want to include the output literally in an
+HTML <code><script></code> tag you can use this option to prevent <code></script</code> from
+showing up in the output.
+</li>
+</ul>
+
+
+
+</div>
+
+<div id="outline-container-1_4_1" class="outline-4">
+<h4 id="sec-1_4_1"><span class="section-number-4">1.4.1</span> API </h4>
+<div class="outline-text-4" id="text-1_4_1">
+
+
+<p>
+To use the library from JavaScript, you'd do the following (example for
+NodeJS):
+</p>
+
+
+
+<pre class="src src-js"><span style="color: #8b0000;">var</span> <span style="color: #8b008b;">jsp</span> = require(<span style="color: #008b00;">"uglify-js"</span>).parser;
+<span style="color: #8b0000;">var</span> <span style="color: #8b008b;">pro</span> = require(<span style="color: #008b00;">"uglify-js"</span>).uglify;
+
+<span style="color: #8b0000;">var</span> <span style="color: #8b008b;">orig_code</span> = <span style="color: #008b00;">"... JS code here"</span>;
+<span style="color: #8b0000;">var</span> <span style="color: #8b008b;">ast</span> = jsp.parse(orig_code); <span style="color: #00008b;">// </span><span style="color: #00008b;">parse code and get the initial AST
+</span>ast = pro.ast_mangle(ast); <span style="color: #00008b;">// </span><span style="color: #00008b;">get a new AST with mangled names
+</span>ast = pro.ast_squeeze(ast); <span style="color: #00008b;">// </span><span style="color: #00008b;">get an AST with compression optimizations
+</span><span style="color: #8b0000;">var</span> <span style="color: #8b008b;">final_code</span> = pro.gen_code(ast); <span style="color: #00008b;">// </span><span style="color: #00008b;">compressed code here
+</span></pre>
+
+
+
+<p>
+The above performs the full compression that is possible right now. As you
+can see, there are a sequence of steps which you can apply. For example if
+you want compressed output but for some reason you don't want to mangle
+variable names, you would simply skip the line that calls
+<code>pro.ast_mangle(ast)</code>.
+</p>
+<p>
+Some of these functions take optional arguments. Here's a description:
+</p>
+<ul>
+<li>
+<code>jsp.parse(code, strict_semicolons)</code> – parses JS code and returns an AST.
+<code>strict_semicolons</code> is optional and defaults to <code>false</code>. If you pass
+<code>true</code> then the parser will throw an error when it expects a semicolon and
+it doesn't find it. For most JS code you don't want that, but it's useful
+if you want to strictly sanitize your code.
+
+</li>
+<li>
+<code>pro.ast_mangle(ast, options)</code> – generates a new AST containing mangled
+(compressed) variable and function names. It supports the following
+options:
+
+<ul>
+<li>
+<code>toplevel</code> – mangle toplevel names (by default we don't touch them).
+</li>
+<li>
+<code>except</code> – an array of names to exclude from compression.
+
+</li>
+</ul>
+</li>
+<li>
+<code>pro.ast_squeeze(ast, options)</code> – employs further optimizations designed
+to reduce the size of the code that <code>gen_code</code> would generate from the
+AST. Returns a new AST. <code>options</code> can be a hash; the supported options
+are:
+
+<ul>
+<li>
+<code>make_seqs</code> (default true) which will cause consecutive statements in a
+block to be merged using the "sequence" (comma) operator
+
+</li>
+<li>
+<code>dead_code</code> (default true) which will remove unreachable code.
+
+</li>
+</ul>
+</li>
+<li>
+<code>pro.gen_code(ast, options)</code> – generates JS code from the AST. By
+default it's minified, but using the <code>options</code> argument you can get nicely
+formatted output. <code>options</code> is, well, optional :-) and if you pass it it
+must be an object and supports the following properties (below you can see
+the default values):
+
+<ul>
+<li>
+<code>beautify: false</code> – pass <code>true</code> if you want indented output
+</li>
+<li>
+<code>indent_start: 0</code> (only applies when <code>beautify</code> is <code>true</code>) – initial
+indentation in spaces
+</li>
+<li>
+<code>indent_level: 4</code> (only applies when <code>beautify</code> is <code>true</code>) --
+indentation level, in spaces (pass an even number)
+</li>
+<li>
+<code>quote_keys: false</code> – if you pass <code>true</code> it will quote all keys in
+literal objects
+</li>
+<li>
+<code>space_colon: false</code> (only applies when <code>beautify</code> is <code>true</code>) – wether
+to put a space before the colon in object literals
+</li>
+<li>
+<code>ascii_only: false</code> – pass <code>true</code> if you want to encode non-ASCII
+characters as <code>\uXXXX</code>.
+</li>
+<li>
+<code>inline_script: false</code> – pass <code>true</code> to escape occurrences of
+<code></script</code> in strings
+</li>
+</ul>
+</li>
+</ul>
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1_4_2" class="outline-4">
+<h4 id="sec-1_4_2"><span class="section-number-4">1.4.2</span> Beautifier shortcoming – no more comments </h4>
+<div class="outline-text-4" id="text-1_4_2">
+
+
+<p>
+The beautifier can be used as a general purpose indentation tool. It's
+useful when you want to make a minified file readable. One limitation,
+though, is that it discards all comments, so you don't really want to use it
+to reformat your code, unless you don't have, or don't care about, comments.
+</p>
+<p>
+In fact it's not the beautifier who discards comments — they are dumped at
+the parsing stage, when we build the initial AST. Comments don't really
+make sense in the AST, and while we could add nodes for them, it would be
+inconvenient because we'd have to add special rules to ignore them at all
+the processing stages.
+</p>
+</div>
+</div>
+
+</div>
+
+<div id="outline-container-1_5" class="outline-3">
+<h3 id="sec-1_5"><span class="section-number-3">1.5</span> Compression – how good is it? </h3>
+<div class="outline-text-3" id="text-1_5">
+
+
+<p>
+(XXX: this is somewhat outdated. On the jQuery source code we beat Closure
+by 168 bytes (560 after gzip) and by many seconds.)
+</p>
+<p>
+There are a few popular JS minifiers nowadays – the two most well known
+being the GoogleClosure (GCL) compiler and the YUI compressor. For some
+reason they are both written in Java. I didn't really hope to beat any of
+them, but finally I did – UglifyJS compresses better than the YUI
+compressor, and safer than GoogleClosure.
+</p>
+<p>
+I tested it on two big libraries. <a href="http://www.dynarchlib.com/">DynarchLIB</a> is my own, and it's big enough
+to contain probably all the JavaScript tricks known to mankind. <a href="http://jquery.com/">jQuery</a> is
+definitely the most popular JavaScript library (to some people, it's a
+synonym to JavaScript itself).
+</p>
+<p>
+I cannot swear that there are no bugs in the generated codes, but they
+appear to work fine.
+</p>
+<p>
+Compression results:
+</p>
+<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
+<caption></caption>
+<colgroup><col align="left" /><col align="right" /><col align="right" /><col align="left" /><col align="left" />
+</colgroup>
+<thead>
+<tr><th scope="col">Library</th><th scope="col">Orig. size</th><th scope="col">UglifyJS</th><th scope="col">YUI</th><th scope="col">GCL</th></tr>
+</thead>
+<tbody>
+<tr><td>DynarchLIB</td><td>636896</td><td>241441</td><td>246452 (+5011)</td><td>240439 (-1002) (buggy)</td></tr>
+<tr><td>jQuery</td><td>163855</td><td>72006</td><td>79702 (+7696)</td><td>71858 (-148)</td></tr>
+</tbody>
+</table>
+
+
+<p>
+UglifyJS is the fastest to run. On my laptop UglifyJS takes 1.35s for
+DynarchLIB, while YUI takes 2.7s and GCL takes 6.5s.
+</p>
+<p>
+GoogleClosure does a lot of smart ass optimizations. I had to strive really
+hard to get close to it. It should be possible to even beat it, but then
+again, GCL has a gazillion lines of code and runs terribly slow, so I'm not
+sure it worths spending the effort to save a few bytes. Also, GCL doesn't
+cope with <code>eval()</code> or <code>with{}</code> – it just dumps a warning and proceeds to
+mangle names anyway; my DynarchLIB compiled with it is buggy because of
+this.
+</p>
+<p>
+UglifyJS consists of ~1100 lines of code for the tokenizer/parser, and ~1100
+lines for the compressor and code generator. That should make it very
+maintainable and easily extensible, so I would say it has a good place in
+this field and it's bound to become the de-facto standard JS minifier. And
+I shall rule the world. :-) Use it, and <b>spread the word</b>!
+</p>
+</div>
+
+</div>
+
+<div id="outline-container-1_6" class="outline-3">
+<h3 id="sec-1_6"><span class="section-number-3">1.6</span> Bugs? </h3>
+<div class="outline-text-3" id="text-1_6">
+
+
+<p>
+Unfortunately, for the time being there is no automated test suite. But I
+ran the compressor manually on non-trivial code, and then I tested that the
+generated code works as expected. A few hundred times.
+</p>
+<p>
+DynarchLIB was started in times when there was no good JS minifier.
+Therefore I was quite religious about trying to write short code manually,
+and as such DL contains a lot of syntactic hacks<sup><a class="footref" name="fnr.1" href="#fn.1">1</a></sup> such as “foo == bar ? a
+= 10 : b = 20”, though the more readable version would clearly be to use
+“if/else”.
+</p>
+<p>
+Since the parser/compressor runs fine on DL and jQuery, I'm quite confident
+that it's solid enough for production use. If you can identify any bugs,
+I'd love to hear about them (<a href="http://groups.google.com/group/uglifyjs">use the Google Group</a> or email me directly).
+</p>
+</div>
+
+</div>
+
+<div id="outline-container-1_7" class="outline-3">
+<h3 id="sec-1_7"><span class="section-number-3">1.7</span> Links </h3>
+<div class="outline-text-3" id="text-1_7">
+
+
+<ul>
+<li>
+Project at GitHub: <a href="http://github.com/mishoo/UglifyJS">http://github.com/mishoo/UglifyJS</a>
+</li>
+<li>
+Google Group: <a href="http://groups.google.com/group/uglifyjs">http://groups.google.com/group/uglifyjs</a>
+</li>
+<li>
+Common Lisp JS parser: <a href="http://marijn.haverbeke.nl/parse-js/">http://marijn.haverbeke.nl/parse-js/</a>
+</li>
+<li>
+JS-to-Lisp compiler: <a href="http://github.com/marijnh/js">http://github.com/marijnh/js</a>
+</li>
+<li>
+Common Lisp JS uglifier: <a href="http://github.com/mishoo/cl-uglify-js">http://github.com/mishoo/cl-uglify-js</a>
+</li>
+</ul>
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1_8" class="outline-3">
+<h3 id="sec-1_8"><span class="section-number-3">1.8</span> License </h3>
+<div class="outline-text-3" id="text-1_8">
+
+
+<p>
+UglifyJS is released under the BSD license:
+</p>
+
+
+
+<pre class="example">Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+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.
+</pre>
+
+
+
+
+</div>
+</div>
+</div>
+<div id="footnotes">
+<h2 class="footnotes">Footnotes: </h2>
+<div id="text-footnotes">
+<p class="footnote"><sup><a class="footnum" name="fn.1" href="#fnr.1">1</a></sup> I even reported a few bugs and suggested some fixes in the original
+<a href="http://marijn.haverbeke.nl/parse-js/">parse-js</a> library, and Marijn pushed fixes literally in minutes.
+</p>
+</div>
+</div>
+<div id="postamble">
+<p class="author"> Author: Mihai Bazon
+</p>
+<p class="date"> Date: 2011-07-14 12:50:31 EEST</p>
+<p class="creator">HTML generated by org-mode 7.01trans in emacs 23</p>
+</div>
+</div>
+</body>
+</html>
--- /dev/null
+#+TITLE: UglifyJS -- a JavaScript parser/compressor/beautifier
+#+KEYWORDS: javascript, js, parser, compiler, compressor, mangle, minify, minifier
+#+DESCRIPTION: a JavaScript parser/compressor/beautifier in JavaScript
+#+STYLE: <link rel="stylesheet" type="text/css" href="docstyle.css" />
+#+AUTHOR: Mihai Bazon
+#+EMAIL: mihai.bazon@gmail.com
+
+* UglifyJS --- a JavaScript parser/compressor/beautifier
+
+This package implements a general-purpose JavaScript
+parser/compressor/beautifier toolkit. It is developed on [[http://nodejs.org/][NodeJS]], but it
+should work on any JavaScript platform supporting the CommonJS module system
+(and if your platform of choice doesn't support CommonJS, you can easily
+implement it, or discard the =exports.*= lines from UglifyJS sources).
+
+The tokenizer/parser generates an abstract syntax tree from JS code. You
+can then traverse the AST to learn more about the code, or do various
+manipulations on it. This part is implemented in [[../lib/parse-js.js][parse-js.js]] and it's a
+port to JavaScript of the excellent [[http://marijn.haverbeke.nl/parse-js/][parse-js]] Common Lisp library from [[http://marijn.haverbeke.nl/][Marijn
+Haverbeke]].
+
+( See [[http://github.com/mishoo/cl-uglify-js][cl-uglify-js]] if you're looking for the Common Lisp version of
+UglifyJS. )
+
+The second part of this package, implemented in [[../lib/process.js][process.js]], inspects and
+manipulates the AST generated by the parser to provide the following:
+
+- ability to re-generate JavaScript code from the AST. Optionally
+ indented---you can use this if you want to “beautify” a program that has
+ been compressed, so that you can inspect the source. But you can also run
+ our code generator to print out an AST without any whitespace, so you
+ achieve compression as well.
+
+- shorten variable names (usually to single characters). Our mangler will
+ analyze the code and generate proper variable names, depending on scope
+ and usage, and is smart enough to deal with globals defined elsewhere, or
+ with =eval()= calls or =with{}= statements. In short, if =eval()= or
+ =with{}= are used in some scope, then all variables in that scope and any
+ variables in the parent scopes will remain unmangled, and any references
+ to such variables remain unmangled as well.
+
+- various small optimizations that may lead to faster code but certainly
+ lead to smaller code. Where possible, we do the following:
+
+ - foo["bar"] ==> foo.bar
+
+ - remove block brackets ={}=
+
+ - join consecutive var declarations:
+ var a = 10; var b = 20; ==> var a=10,b=20;
+
+ - resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the
+ replacement if the result occupies less bytes; for example 1/3 would
+ translate to 0.333333333333, so in this case we don't replace it.
+
+ - consecutive statements in blocks are merged into a sequence; in many
+ cases, this leaves blocks with a single statement, so then we can remove
+ the block brackets.
+
+ - various optimizations for IF statements:
+
+ - if (foo) bar(); else baz(); ==> foo?bar():baz();
+ - if (!foo) bar(); else baz(); ==> foo?baz():bar();
+ - if (foo) bar(); ==> foo&&bar();
+ - if (!foo) bar(); ==> foo||bar();
+ - if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
+ - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+
+ - remove some unreachable code and warn about it (code that follows a
+ =return=, =throw=, =break= or =continue= statement, except
+ function/variable declarations).
+
+** <<Unsafe transformations>>
+
+UglifyJS tries its best to achieve great compression while leaving the
+semantics of the code intact. In general, if your code logic is broken by
+UglifyJS then it's a bug in UglifyJS and you should report it and I should
+fix it. :-)
+
+However, I opted to include the following potentially unsafe transformations
+as default behavior. Discussion is welcome, if you have ideas of how to
+handle this better, or any objections to these optimizations, please let me
+know.
+
+*** Calls involving the global Array constructor
+
+The following transformations occur:
+
+#+BEGIN_SRC js
+new Array(1, 2, 3, 4) => [1,2,3,4]
+Array(a, b, c) => [a,b,c]
+new Array(5) => Array(5)
+new Array(a) => Array(a)
+#+END_SRC
+
+These are all safe if the Array name isn't redefined. JavaScript does allow
+one to globally redefine Array (and pretty much everything, in fact) but I
+personally don't see why would anyone do that.
+
+UglifyJS does handle the case where Array is redefined locally, or even
+globally but with a =function= or =var= declaration. Therefore, in the
+following cases UglifyJS *doesn't touch* calls or instantiations of Array:
+
+#+BEGIN_SRC js
+// case 1. globally declared variable
+ var Array;
+ new Array(1, 2, 3);
+ Array(a, b);
+
+ // or (can be declared later)
+ new Array(1, 2, 3);
+ var Array;
+
+ // or (can be a function)
+ new Array(1, 2, 3);
+ function Array() { ... }
+
+// case 2. declared in a function
+ (function(){
+ a = new Array(1, 2, 3);
+ b = Array(5, 6);
+ var Array;
+ })();
+
+ // or
+ (function(Array){
+ return Array(5, 6, 7);
+ })();
+
+ // or
+ (function(){
+ return new Array(1, 2, 3, 4);
+ function Array() { ... }
+ })();
+
+ // etc.
+#+END_SRC
+
+** Install (NPM)
+
+UglifyJS is now available through NPM --- =npm install uglify-js= should do
+the job.
+
+** Install latest code from GitHub
+
+#+BEGIN_SRC sh
+## clone the repository
+mkdir -p /where/you/wanna/put/it
+cd /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+## make the module available to Node
+mkdir -p ~/.node_libraries/
+cd ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+## and if you want the CLI script too:
+mkdir -p ~/bin
+cd ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ # (then add ~/bin to your $PATH if it's not there already)
+#+END_SRC
+
+** Usage
+
+There is a command-line tool that exposes the functionality of this library
+for your shell-scripting needs:
+
+#+BEGIN_SRC sh
+uglifyjs [ options... ] [ filename ]
+#+END_SRC
+
+=filename= should be the last argument and should name the file from which
+to read the JavaScript code. If you don't specify it, it will read code
+from STDIN.
+
+Supported options:
+
+- =-b= or =--beautify= --- output indented code; when passed, additional
+ options control the beautifier:
+
+ - =-i N= or =--indent N= --- indentation level (number of spaces)
+
+ - =-q= or =--quote-keys= --- quote keys in literal objects (by default,
+ only keys that cannot be identifier names will be quotes).
+
+- =--ascii= --- pass this argument to encode non-ASCII characters as
+ =\uXXXX= sequences. By default UglifyJS won't bother to do it and will
+ output Unicode characters instead. (the output is always encoded in UTF8,
+ but if you pass this option you'll only get ASCII).
+
+- =-nm= or =--no-mangle= --- don't mangle variable names
+
+- =-ns= or =--no-squeeze= --- don't call =ast_squeeze()= (which does various
+ optimizations that result in smaller, less readable code).
+
+- =-mt= or =--mangle-toplevel= --- mangle names in the toplevel scope too
+ (by default we don't do this).
+
+- =--no-seqs= --- when =ast_squeeze()= is called (thus, unless you pass
+ =--no-squeeze=) it will reduce consecutive statements in blocks into a
+ sequence. For example, "a = 10; b = 20; foo();" will be written as
+ "a=10,b=20,foo();". In various occasions, this allows us to discard the
+ block brackets (since the block becomes a single statement). This is ON
+ by default because it seems safe and saves a few hundred bytes on some
+ libs that I tested it on, but pass =--no-seqs= to disable it.
+
+- =--no-dead-code= --- by default, UglifyJS will remove code that is
+ obviously unreachable (code that follows a =return=, =throw=, =break= or
+ =continue= statement and is not a function/variable declaration). Pass
+ this option to disable this optimization.
+
+- =-nc= or =--no-copyright= --- by default, =uglifyjs= will keep the initial
+ comment tokens in the generated code (assumed to be copyright information
+ etc.). If you pass this it will discard it.
+
+- =-o filename= or =--output filename= --- put the result in =filename=. If
+ this isn't given, the result goes to standard output (or see next one).
+
+- =--overwrite= --- if the code is read from a file (not from STDIN) and you
+ pass =--overwrite= then the output will be written in the same file.
+
+- =--ast= --- pass this if you want to get the Abstract Syntax Tree instead
+ of JavaScript as output. Useful for debugging or learning more about the
+ internals.
+
+- =-v= or =--verbose= --- output some notes on STDERR (for now just how long
+ each operation takes).
+
+- =--extra= --- enable additional optimizations that have not yet been
+ extensively tested. These might, or might not, break your code. If you
+ find a bug using this option, please report a test case.
+
+- =--unsafe= --- enable other additional optimizations that are known to be
+ unsafe in some contrived situations, but could still be generally useful.
+ For now only this:
+
+ - foo.toString() ==> foo+""
+
+- =--max-line-len= (default 32K characters) --- add a newline after around
+ 32K characters. I've seen both FF and Chrome croak when all the code was
+ on a single line of around 670K. Pass --max-line-len 0 to disable this
+ safety feature.
+
+- =--reserved-names= --- some libraries rely on certain names to be used, as
+ pointed out in issue #92 and #81, so this option allow you to exclude such
+ names from the mangler. For example, to keep names =require= and =$super=
+ intact you'd specify --reserved-names "require,$super".
+
+- =--inline-script= -- when you want to include the output literally in an
+ HTML =<script>= tag you can use this option to prevent =</script= from
+ showing up in the output.
+
+*** API
+
+To use the library from JavaScript, you'd do the following (example for
+NodeJS):
+
+#+BEGIN_SRC js
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+var orig_code = "... JS code here";
+var ast = jsp.parse(orig_code); // parse code and get the initial AST
+ast = pro.ast_mangle(ast); // get a new AST with mangled names
+ast = pro.ast_squeeze(ast); // get an AST with compression optimizations
+var final_code = pro.gen_code(ast); // compressed code here
+#+END_SRC
+
+The above performs the full compression that is possible right now. As you
+can see, there are a sequence of steps which you can apply. For example if
+you want compressed output but for some reason you don't want to mangle
+variable names, you would simply skip the line that calls
+=pro.ast_mangle(ast)=.
+
+Some of these functions take optional arguments. Here's a description:
+
+- =jsp.parse(code, strict_semicolons)= -- parses JS code and returns an AST.
+ =strict_semicolons= is optional and defaults to =false=. If you pass
+ =true= then the parser will throw an error when it expects a semicolon and
+ it doesn't find it. For most JS code you don't want that, but it's useful
+ if you want to strictly sanitize your code.
+
+- =pro.ast_mangle(ast, options)= -- generates a new AST containing mangled
+ (compressed) variable and function names. It supports the following
+ options:
+
+ - =toplevel= -- mangle toplevel names (by default we don't touch them).
+ - =except= -- an array of names to exclude from compression.
+
+- =pro.ast_squeeze(ast, options)= -- employs further optimizations designed
+ to reduce the size of the code that =gen_code= would generate from the
+ AST. Returns a new AST. =options= can be a hash; the supported options
+ are:
+
+ - =make_seqs= (default true) which will cause consecutive statements in a
+ block to be merged using the "sequence" (comma) operator
+
+ - =dead_code= (default true) which will remove unreachable code.
+
+- =pro.gen_code(ast, options)= -- generates JS code from the AST. By
+ default it's minified, but using the =options= argument you can get nicely
+ formatted output. =options= is, well, optional :-) and if you pass it it
+ must be an object and supports the following properties (below you can see
+ the default values):
+
+ - =beautify: false= -- pass =true= if you want indented output
+ - =indent_start: 0= (only applies when =beautify= is =true=) -- initial
+ indentation in spaces
+ - =indent_level: 4= (only applies when =beautify= is =true=) --
+ indentation level, in spaces (pass an even number)
+ - =quote_keys: false= -- if you pass =true= it will quote all keys in
+ literal objects
+ - =space_colon: false= (only applies when =beautify= is =true=) -- wether
+ to put a space before the colon in object literals
+ - =ascii_only: false= -- pass =true= if you want to encode non-ASCII
+ characters as =\uXXXX=.
+ - =inline_script: false= -- pass =true= to escape occurrences of
+ =</script= in strings
+
+*** Beautifier shortcoming -- no more comments
+
+The beautifier can be used as a general purpose indentation tool. It's
+useful when you want to make a minified file readable. One limitation,
+though, is that it discards all comments, so you don't really want to use it
+to reformat your code, unless you don't have, or don't care about, comments.
+
+In fact it's not the beautifier who discards comments --- they are dumped at
+the parsing stage, when we build the initial AST. Comments don't really
+make sense in the AST, and while we could add nodes for them, it would be
+inconvenient because we'd have to add special rules to ignore them at all
+the processing stages.
+
+** Compression -- how good is it?
+
+(XXX: this is somewhat outdated. On the jQuery source code we beat Closure
+by 168 bytes (560 after gzip) and by many seconds.)
+
+There are a few popular JS minifiers nowadays -- the two most well known
+being the GoogleClosure (GCL) compiler and the YUI compressor. For some
+reason they are both written in Java. I didn't really hope to beat any of
+them, but finally I did -- UglifyJS compresses better than the YUI
+compressor, and safer than GoogleClosure.
+
+I tested it on two big libraries. [[http://www.dynarchlib.com/][DynarchLIB]] is my own, and it's big enough
+to contain probably all the JavaScript tricks known to mankind. [[http://jquery.com/][jQuery]] is
+definitely the most popular JavaScript library (to some people, it's a
+synonym to JavaScript itself).
+
+I cannot swear that there are no bugs in the generated codes, but they
+appear to work fine.
+
+Compression results:
+
+| Library | Orig. size | UglifyJS | YUI | GCL |
+|------------+------------+----------+----------------+------------------------|
+| DynarchLIB | 636896 | 241441 | 246452 (+5011) | 240439 (-1002) (buggy) |
+| jQuery | 163855 | 72006 | 79702 (+7696) | 71858 (-148) |
+
+UglifyJS is the fastest to run. On my laptop UglifyJS takes 1.35s for
+DynarchLIB, while YUI takes 2.7s and GCL takes 6.5s.
+
+GoogleClosure does a lot of smart ass optimizations. I had to strive really
+hard to get close to it. It should be possible to even beat it, but then
+again, GCL has a gazillion lines of code and runs terribly slow, so I'm not
+sure it worths spending the effort to save a few bytes. Also, GCL doesn't
+cope with =eval()= or =with{}= -- it just dumps a warning and proceeds to
+mangle names anyway; my DynarchLIB compiled with it is buggy because of
+this.
+
+UglifyJS consists of ~1100 lines of code for the tokenizer/parser, and ~1100
+lines for the compressor and code generator. That should make it very
+maintainable and easily extensible, so I would say it has a good place in
+this field and it's bound to become the de-facto standard JS minifier. And
+I shall rule the world. :-) Use it, and *spread the word*!
+
+** Bugs?
+
+Unfortunately, for the time being there is no automated test suite. But I
+ran the compressor manually on non-trivial code, and then I tested that the
+generated code works as expected. A few hundred times.
+
+DynarchLIB was started in times when there was no good JS minifier.
+Therefore I was quite religious about trying to write short code manually,
+and as such DL contains a lot of syntactic hacks[1] such as “foo == bar ? a
+= 10 : b = 20”, though the more readable version would clearly be to use
+“if/else”.
+
+Since the parser/compressor runs fine on DL and jQuery, I'm quite confident
+that it's solid enough for production use. If you can identify any bugs,
+I'd love to hear about them ([[http://groups.google.com/group/uglifyjs][use the Google Group]] or email me directly).
+
+[1] I even reported a few bugs and suggested some fixes in the original
+ [[http://marijn.haverbeke.nl/parse-js/][parse-js]] library, and Marijn pushed fixes literally in minutes.
+
+** Links
+
+- Project at GitHub: [[http://github.com/mishoo/UglifyJS][http://github.com/mishoo/UglifyJS]]
+- Google Group: [[http://groups.google.com/group/uglifyjs][http://groups.google.com/group/uglifyjs]]
+- Common Lisp JS parser: [[http://marijn.haverbeke.nl/parse-js/][http://marijn.haverbeke.nl/parse-js/]]
+- JS-to-Lisp compiler: [[http://github.com/marijnh/js][http://github.com/marijnh/js]]
+- Common Lisp JS uglifier: [[http://github.com/mishoo/cl-uglify-js][http://github.com/mishoo/cl-uglify-js]]
+
+** License
+
+UglifyJS is released under the BSD license:
+
+#+BEGIN_EXAMPLE
+Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+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.
+#+END_EXAMPLE
--- /dev/null
+#! /usr/bin/env node
+// -*- js -*-
+
+global.sys = require(/^v0\.[012]/.test(process.version) ? "sys" : "util");
+var fs = require("fs");
+var uglify = require("uglify-js"), // symlink ~/.node_libraries/uglify-js.js to ../uglify-js.js
+ jsp = uglify.parser,
+ pro = uglify.uglify;
+
+var options = {
+ ast: false,
+ mangle: true,
+ mangle_toplevel: false,
+ squeeze: true,
+ make_seqs: true,
+ dead_code: true,
+ verbose: false,
+ show_copyright: true,
+ out_same_file: false,
+ max_line_length: 32 * 1024,
+ unsafe: false,
+ reserved_names: null,
+ defines: { },
+ codegen_options: {
+ ascii_only: false,
+ beautify: false,
+ indent_level: 4,
+ indent_start: 0,
+ quote_keys: false,
+ space_colon: false,
+ inline_script: false
+ },
+ make: false,
+ output: true // stdout
+};
+
+var args = jsp.slice(process.argv, 2);
+var filename;
+
+out: while (args.length > 0) {
+ var v = args.shift();
+ switch (v) {
+ case "-b":
+ case "--beautify":
+ options.codegen_options.beautify = true;
+ break;
+ case "-i":
+ case "--indent":
+ options.codegen_options.indent_level = args.shift();
+ break;
+ case "-q":
+ case "--quote-keys":
+ options.codegen_options.quote_keys = true;
+ break;
+ case "-mt":
+ case "--mangle-toplevel":
+ options.mangle_toplevel = true;
+ break;
+ case "--no-mangle":
+ case "-nm":
+ options.mangle = false;
+ break;
+ case "--no-squeeze":
+ case "-ns":
+ options.squeeze = false;
+ break;
+ case "--no-seqs":
+ options.make_seqs = false;
+ break;
+ case "--no-dead-code":
+ options.dead_code = false;
+ break;
+ case "--no-copyright":
+ case "-nc":
+ options.show_copyright = false;
+ break;
+ case "-o":
+ case "--output":
+ options.output = args.shift();
+ break;
+ case "--overwrite":
+ options.out_same_file = true;
+ break;
+ case "-v":
+ case "--verbose":
+ options.verbose = true;
+ break;
+ case "--ast":
+ options.ast = true;
+ break;
+ case "--unsafe":
+ options.unsafe = true;
+ break;
+ case "--max-line-len":
+ options.max_line_length = parseInt(args.shift(), 10);
+ break;
+ case "--reserved-names":
+ options.reserved_names = args.shift().split(",");
+ break;
+ case "-d":
+ case "--define":
+ var defarg = args.shift();
+ try {
+ var defsym = function(sym) {
+ // KEYWORDS_ATOM doesn't include NaN or Infinity - should we check
+ // for them too ?? We don't check reserved words and the like as the
+ // define values are only substituted AFTER parsing
+ if (jsp.KEYWORDS_ATOM.hasOwnProperty(sym)) {
+ throw "Don't define values for inbuilt constant '"+sym+"'";
+ }
+ return sym;
+ },
+ defval = function(v) {
+ if (v.match(/^"(.*)"$/) || v.match(/^'(.*)'$/)) {
+ return [ "string", RegExp.$1 ];
+ }
+ else if (!isNaN(parseFloat(v))) {
+ return [ "num", parseFloat(v) ];
+ }
+ else if (v.match(/^[a-z\$_][a-z\$_0-9]*$/i)) {
+ return [ "name", v ];
+ }
+ else if (!v.match(/"/)) {
+ return [ "string", v ];
+ }
+ else if (!v.match(/'/)) {
+ return [ "string", v ];
+ }
+ throw "Can't understand the specified value: "+v;
+ };
+ if (defarg.match(/^([a-z_\$][a-z_\$0-9]*)(=(.*))?$/i)) {
+ var sym = defsym(RegExp.$1),
+ val = RegExp.$2 ? defval(RegExp.$2.substr(1)) : [ 'name', 'true' ];
+ options.defines[sym] = val;
+ }
+ else {
+ throw "The --define option expects SYMBOL[=value]";
+ }
+ } catch(ex) {
+ sys.print("ERROR: In option --define "+defarg+"\n"+ex+"\n");
+ process.exit(1);
+ }
+ break;
+ case "--define-from-module":
+ var defmodarg = args.shift(),
+ defmodule = require(defmodarg),
+ sym,
+ val;
+ for (sym in defmodule) {
+ if (defmodule.hasOwnProperty(sym)) {
+ options.defines[sym] = function(val) {
+ if (typeof val == "string")
+ return [ "string", val ];
+ if (typeof val == "number")
+ return [ "num", val ];
+ if (val === true)
+ return [ 'name', 'true' ];
+ if (val === false)
+ return [ 'name', 'false' ];
+ if (val === null)
+ return [ 'name', 'null' ];
+ if (val === undefined)
+ return [ 'name', 'undefined' ];
+ sys.print("ERROR: In option --define-from-module "+defmodarg+"\n");
+ sys.print("ERROR: Unknown object type for: "+sym+"="+val+"\n");
+ process.exit(1);
+ return null;
+ }(defmodule[sym]);
+ }
+ }
+ break;
+ case "--ascii":
+ options.codegen_options.ascii_only = true;
+ break;
+ case "--make":
+ options.make = true;
+ break;
+ case "--inline-script":
+ options.codegen_options.inline_script = true;
+ break;
+ default:
+ filename = v;
+ break out;
+ }
+}
+
+if (options.verbose) {
+ pro.set_logger(function(msg){
+ sys.debug(msg);
+ });
+}
+
+jsp.set_logger(function(msg){
+ sys.debug(msg);
+});
+
+if (options.make) {
+ options.out_same_file = false; // doesn't make sense in this case
+ var makefile = JSON.parse(fs.readFileSync(filename || "Makefile.uglify.js").toString());
+ output(makefile.files.map(function(file){
+ var code = fs.readFileSync(file.name);
+ if (file.module) {
+ code = "!function(exports, global){global = this;\n" + code + "\n;this." + file.module + " = exports;}({})";
+ }
+ else if (file.hide) {
+ code = "(function(){" + code + "}());";
+ }
+ return squeeze_it(code);
+ }).join("\n"));
+}
+else if (filename) {
+ fs.readFile(filename, "utf8", function(err, text){
+ if (err) throw err;
+ output(squeeze_it(text));
+ });
+}
+else {
+ var stdin = process.openStdin();
+ stdin.setEncoding("utf8");
+ var text = "";
+ stdin.on("data", function(chunk){
+ text += chunk;
+ });
+ stdin.on("end", function() {
+ output(squeeze_it(text));
+ });
+}
+
+function output(text) {
+ var out;
+ if (options.out_same_file && filename)
+ options.output = filename;
+ if (options.output === true) {
+ out = process.stdout;
+ } else {
+ out = fs.createWriteStream(options.output, {
+ flags: "w",
+ encoding: "utf8",
+ mode: 0644
+ });
+ }
+ out.write(text);
+ if (options.output !== true) {
+ out.end();
+ }
+};
+
+// --------- main ends here.
+
+function show_copyright(comments) {
+ var ret = "";
+ for (var i = 0; i < comments.length; ++i) {
+ var c = comments[i];
+ if (c.type == "comment1") {
+ ret += "//" + c.value + "\n";
+ } else {
+ ret += "/*" + c.value + "*/";
+ }
+ }
+ return ret;
+};
+
+function squeeze_it(code) {
+ var result = "";
+ if (options.show_copyright) {
+ var tok = jsp.tokenizer(code), c;
+ c = tok();
+ result += show_copyright(c.comments_before);
+ }
+ try {
+ var ast = time_it("parse", function(){ return jsp.parse(code); });
+ if (options.mangle) ast = time_it("mangle", function(){
+ return pro.ast_mangle(ast, {
+ toplevel: options.mangle_toplevel,
+ defines: options.defines,
+ except: options.reserved_names
+ });
+ });
+ if (options.squeeze) ast = time_it("squeeze", function(){
+ ast = pro.ast_squeeze(ast, {
+ make_seqs : options.make_seqs,
+ dead_code : options.dead_code,
+ keep_comps : !options.unsafe
+ });
+ if (options.unsafe)
+ ast = pro.ast_squeeze_more(ast);
+ return ast;
+ });
+ if (options.ast)
+ return sys.inspect(ast, null, null);
+ result += time_it("generate", function(){ return pro.gen_code(ast, options.codegen_options) });
+ if (!options.codegen_options.beautify && options.max_line_length) {
+ result = time_it("split", function(){ return pro.split_lines(result, options.max_line_length) });
+ }
+ return result;
+ } catch(ex) {
+ sys.debug(ex.stack);
+ sys.debug(sys.inspect(ex));
+ sys.debug(JSON.stringify(ex));
+ }
+};
+
+function time_it(name, cont) {
+ if (!options.verbose)
+ return cont();
+ var t1 = new Date().getTime();
+ try { return cont(); }
+ finally { sys.debug("// " + name + ": " + ((new Date().getTime() - t1) / 1000).toFixed(3) + " sec."); }
+};
--- /dev/null
+html { font-family: "Lucida Grande","Trebuchet MS",sans-serif; font-size: 12pt; }
+body { max-width: 60em; }
+.title { text-align: center; }
+.todo { color: red; }
+.done { color: green; }
+.tag { background-color:lightblue; font-weight:normal }
+.target { }
+.timestamp { color: grey }
+.timestamp-kwd { color: CadetBlue }
+p.verse { margin-left: 3% }
+pre {
+ border: 1pt solid #AEBDCC;
+ background-color: #F3F5F7;
+ padding: 5pt;
+ font-family: monospace;
+ font-size: 90%;
+ overflow:auto;
+}
+pre.src {
+ background-color: #eee; color: #112; border: 1px solid #000;
+}
+table { border-collapse: collapse; }
+td, th { vertical-align: top; }
+dt { font-weight: bold; }
+div.figure { padding: 0.5em; }
+div.figure p { text-align: center; }
+.linenr { font-size:smaller }
+.code-highlighted {background-color:#ffff00;}
+.org-info-js_info-navigation { border-style:none; }
+#org-info-js_console-label { font-size:10px; font-weight:bold;
+ white-space:nowrap; }
+.org-info-js_search-highlight {background-color:#ffff00; color:#000000;
+ font-weight:bold; }
+
+sup {
+ vertical-align: baseline;
+ position: relative;
+ top: -0.5em;
+ font-size: 80%;
+}
+
+sup a:link, sup a:visited {
+ text-decoration: none;
+ color: #c00;
+}
+
+sup a:before { content: "["; color: #999; }
+sup a:after { content: "]"; color: #999; }
+
+h1.title { border-bottom: 4px solid #000; padding-bottom: 5px; margin-bottom: 2em; }
+
+#postamble {
+ color: #777;
+ font-size: 90%;
+ padding-top: 1em; padding-bottom: 1em; border-top: 1px solid #999;
+ margin-top: 2em;
+ padding-left: 2em;
+ padding-right: 2em;
+ text-align: right;
+}
+
+#postamble p { margin: 0; }
+
+#footnotes { border-top: 1px solid #000; }
+
+h1 { font-size: 200% }
+h2 { font-size: 175% }
+h3 { font-size: 150% }
+h4 { font-size: 125% }
+
+h1, h2, h3, h4 { font-family: "Bookman",Georgia,"Times New Roman",serif; font-weight: normal; }
+
+@media print {
+ html { font-size: 11pt; }
+}
--- /dev/null
+/***********************************************************************
+
+ A JavaScript tokenizer / parser / beautifier / compressor.
+
+ This version is suitable for Node.js. With minimal changes (the
+ exports stuff) it should work on any JS platform.
+
+ This file contains the tokenizer/parser. It is a port to JavaScript
+ of parse-js [1], a JavaScript parser library written in Common Lisp
+ by Marijn Haverbeke. Thank you Marijn!
+
+ [1] http://marijn.haverbeke.nl/parse-js/
+
+ Exported functions:
+
+ - tokenizer(code) -- returns a function. Call the returned
+ function to fetch the next token.
+
+ - parse(code) -- returns an AST of the given JavaScript code.
+
+ -------------------------------- (C) ---------------------------------
+
+ Author: Mihai Bazon
+ <mihai.bazon@gmail.com>
+ http://mihai.bazon.net/blog
+
+ Distributed under the BSD license:
+
+ Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+ Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+ 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.
+
+ ***********************************************************************/
+
+/* -----[ Tokenizer (constants) ]----- */
+
+var KEYWORDS = array_to_hash([
+ "break",
+ "case",
+ "catch",
+ "const",
+ "continue",
+ "default",
+ "delete",
+ "do",
+ "else",
+ "finally",
+ "for",
+ "function",
+ "if",
+ "in",
+ "instanceof",
+ "new",
+ "return",
+ "switch",
+ "throw",
+ "try",
+ "typeof",
+ "var",
+ "void",
+ "while",
+ "with"
+]);
+
+var RESERVED_WORDS = array_to_hash([
+ "abstract",
+ "boolean",
+ "byte",
+ "char",
+ "class",
+ "debugger",
+ "double",
+ "enum",
+ "export",
+ "extends",
+ "final",
+ "float",
+ "goto",
+ "implements",
+ "import",
+ "int",
+ "interface",
+ "long",
+ "native",
+ "package",
+ "private",
+ "protected",
+ "public",
+ "short",
+ "static",
+ "super",
+ "synchronized",
+ "throws",
+ "transient",
+ "volatile"
+]);
+
+var KEYWORDS_BEFORE_EXPRESSION = array_to_hash([
+ "return",
+ "new",
+ "delete",
+ "throw",
+ "else",
+ "case"
+]);
+
+var KEYWORDS_ATOM = array_to_hash([
+ "false",
+ "null",
+ "true",
+ "undefined"
+]);
+
+var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^"));
+
+var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
+var RE_OCT_NUMBER = /^0[0-7]+$/;
+var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
+
+var OPERATORS = array_to_hash([
+ "in",
+ "instanceof",
+ "typeof",
+ "new",
+ "void",
+ "delete",
+ "++",
+ "--",
+ "+",
+ "-",
+ "!",
+ "~",
+ "&",
+ "|",
+ "^",
+ "*",
+ "/",
+ "%",
+ ">>",
+ "<<",
+ ">>>",
+ "<",
+ ">",
+ "<=",
+ ">=",
+ "==",
+ "===",
+ "!=",
+ "!==",
+ "?",
+ "=",
+ "+=",
+ "-=",
+ "/=",
+ "*=",
+ "%=",
+ ">>=",
+ "<<=",
+ ">>>=",
+ "|=",
+ "^=",
+ "&=",
+ "&&",
+ "||"
+]);
+
+var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\v\u200b"));
+
+var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{}(,.;:"));
+
+var PUNC_CHARS = array_to_hash(characters("[]{}(),;:"));
+
+var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy"));
+
+/* -----[ Tokenizer ]----- */
+
+// regexps adapted from http://xregexp.com/plugins/#unicode
+var UNICODE = {
+ letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+ non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
+ space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
+ connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
+};
+
+function is_letter(ch) {
+ return UNICODE.letter.test(ch);
+};
+
+function is_digit(ch) {
+ ch = ch.charCodeAt(0);
+ return ch >= 48 && ch <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9
+};
+
+function is_alphanumeric_char(ch) {
+ return is_digit(ch) || is_letter(ch);
+};
+
+function is_unicode_combining_mark(ch) {
+ return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
+};
+
+function is_unicode_connector_punctuation(ch) {
+ return UNICODE.connector_punctuation.test(ch);
+};
+
+function is_identifier_start(ch) {
+ return ch == "$" || ch == "_" || is_letter(ch);
+};
+
+function is_identifier_char(ch) {
+ return is_identifier_start(ch)
+ || is_unicode_combining_mark(ch)
+ || is_digit(ch)
+ || is_unicode_connector_punctuation(ch)
+ || ch == "\u200c" // zero-width non-joiner <ZWNJ>
+ || ch == "\u200d" // zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
+ ;
+};
+
+function parse_js_number(num) {
+ if (RE_HEX_NUMBER.test(num)) {
+ return parseInt(num.substr(2), 16);
+ } else if (RE_OCT_NUMBER.test(num)) {
+ return parseInt(num.substr(1), 8);
+ } else if (RE_DEC_NUMBER.test(num)) {
+ return parseFloat(num);
+ }
+};
+
+function JS_Parse_Error(message, line, col, pos) {
+ this.message = message;
+ this.line = line;
+ this.col = col;
+ this.pos = pos;
+ try {
+ ({})();
+ } catch(ex) {
+ this.stack = ex.stack;
+ };
+};
+
+JS_Parse_Error.prototype.toString = function() {
+ return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
+};
+
+function js_error(message, line, col, pos) {
+ throw new JS_Parse_Error(message, line, col, pos);
+};
+
+function is_token(token, type, val) {
+ return token.type == type && (val == null || token.value == val);
+};
+
+var EX_EOF = {};
+
+function tokenizer($TEXT) {
+
+ var S = {
+ text : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, ''),
+ pos : 0,
+ tokpos : 0,
+ line : 0,
+ tokline : 0,
+ col : 0,
+ tokcol : 0,
+ newline_before : false,
+ regex_allowed : false,
+ comments_before : []
+ };
+
+ function peek() { return S.text.charAt(S.pos); };
+
+ function next(signal_eof) {
+ var ch = S.text.charAt(S.pos++);
+ if (signal_eof && !ch)
+ throw EX_EOF;
+ if (ch == "\n") {
+ S.newline_before = true;
+ ++S.line;
+ S.col = 0;
+ } else {
+ ++S.col;
+ }
+ return ch;
+ };
+
+ function eof() {
+ return !S.peek();
+ };
+
+ function find(what, signal_eof) {
+ var pos = S.text.indexOf(what, S.pos);
+ if (signal_eof && pos == -1) throw EX_EOF;
+ return pos;
+ };
+
+ function start_token() {
+ S.tokline = S.line;
+ S.tokcol = S.col;
+ S.tokpos = S.pos;
+ };
+
+ function token(type, value, is_comment) {
+ S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) ||
+ (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) ||
+ (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value)));
+ var ret = {
+ type : type,
+ value : value,
+ line : S.tokline,
+ col : S.tokcol,
+ pos : S.tokpos,
+ nlb : S.newline_before
+ };
+ if (!is_comment) {
+ ret.comments_before = S.comments_before;
+ S.comments_before = [];
+ }
+ S.newline_before = false;
+ return ret;
+ };
+
+ function skip_whitespace() {
+ while (HOP(WHITESPACE_CHARS, peek()))
+ next();
+ };
+
+ function read_while(pred) {
+ var ret = "", ch = peek(), i = 0;
+ while (ch && pred(ch, i++)) {
+ ret += next();
+ ch = peek();
+ }
+ return ret;
+ };
+
+ function parse_error(err) {
+ js_error(err, S.tokline, S.tokcol, S.tokpos);
+ };
+
+ function read_num(prefix) {
+ var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
+ var num = read_while(function(ch, i){
+ if (ch == "x" || ch == "X") {
+ if (has_x) return false;
+ return has_x = true;
+ }
+ if (!has_x && (ch == "E" || ch == "e")) {
+ if (has_e) return false;
+ return has_e = after_e = true;
+ }
+ if (ch == "-") {
+ if (after_e || (i == 0 && !prefix)) return true;
+ return false;
+ }
+ if (ch == "+") return after_e;
+ after_e = false;
+ if (ch == ".") {
+ if (!has_dot && !has_x)
+ return has_dot = true;
+ return false;
+ }
+ return is_alphanumeric_char(ch);
+ });
+ if (prefix)
+ num = prefix + num;
+ var valid = parse_js_number(num);
+ if (!isNaN(valid)) {
+ return token("num", valid);
+ } else {
+ parse_error("Invalid syntax: " + num);
+ }
+ };
+
+ function read_escaped_char() {
+ var ch = next(true);
+ switch (ch) {
+ case "n" : return "\n";
+ case "r" : return "\r";
+ case "t" : return "\t";
+ case "b" : return "\b";
+ case "v" : return "\v";
+ case "f" : return "\f";
+ case "0" : return "\0";
+ case "x" : return String.fromCharCode(hex_bytes(2));
+ case "u" : return String.fromCharCode(hex_bytes(4));
+ default : return ch;
+ }
+ };
+
+ function hex_bytes(n) {
+ var num = 0;
+ for (; n > 0; --n) {
+ var digit = parseInt(next(true), 16);
+ if (isNaN(digit))
+ parse_error("Invalid hex-character pattern in string");
+ num = (num << 4) | digit;
+ }
+ return num;
+ };
+
+ function read_string() {
+ return with_eof_error("Unterminated string constant", function(){
+ var quote = next(), ret = "";
+ for (;;) {
+ var ch = next(true);
+ if (ch == "\\") {
+ // read OctalEscapeSequence (XXX: deprecated if "strict mode")
+ // https://github.com/mishoo/UglifyJS/issues/178
+ var octal_len = 0, first = null;
+ ch = read_while(function(ch){
+ if (ch >= "0" && ch <= "7") {
+ if (!first) {
+ first = ch;
+ return ++octal_len;
+ }
+ else if (first <= "3" && octal_len <= 2) return ++octal_len;
+ else if (first >= "4" && octal_len <= 1) return ++octal_len;
+ }
+ return false;
+ });
+ if (octal_len > 0) ch = String.fromCharCode(parseInt(ch, 8));
+ else ch = read_escaped_char();
+ }
+ else if (ch == quote) break;
+ ret += ch;
+ }
+ return token("string", ret);
+ });
+ };
+
+ function read_line_comment() {
+ next();
+ var i = find("\n"), ret;
+ if (i == -1) {
+ ret = S.text.substr(S.pos);
+ S.pos = S.text.length;
+ } else {
+ ret = S.text.substring(S.pos, i);
+ S.pos = i;
+ }
+ return token("comment1", ret, true);
+ };
+
+ function read_multiline_comment() {
+ next();
+ return with_eof_error("Unterminated multiline comment", function(){
+ var i = find("*/", true),
+ text = S.text.substring(S.pos, i),
+ tok = token("comment2", text, true);
+ S.pos = i + 2;
+ S.line += text.split("\n").length - 1;
+ S.newline_before = text.indexOf("\n") >= 0;
+
+ // https://github.com/mishoo/UglifyJS/issues/#issue/100
+ if (/^@cc_on/i.test(text)) {
+ warn("WARNING: at line " + S.line);
+ warn("*** Found \"conditional comment\": " + text);
+ warn("*** UglifyJS DISCARDS ALL COMMENTS. This means your code might no longer work properly in Internet Explorer.");
+ }
+
+ return tok;
+ });
+ };
+
+ function read_name() {
+ var backslash = false, name = "", ch;
+ while ((ch = peek()) != null) {
+ if (!backslash) {
+ if (ch == "\\") backslash = true, next();
+ else if (is_identifier_char(ch)) name += next();
+ else break;
+ }
+ else {
+ if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX");
+ ch = read_escaped_char();
+ if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
+ name += ch;
+ backslash = false;
+ }
+ }
+ return name;
+ };
+
+ function read_regexp() {
+ return with_eof_error("Unterminated regular expression", function(){
+ var prev_backslash = false, regexp = "", ch, in_class = false;
+ while ((ch = next(true))) if (prev_backslash) {
+ regexp += "\\" + ch;
+ prev_backslash = false;
+ } else if (ch == "[") {
+ in_class = true;
+ regexp += ch;
+ } else if (ch == "]" && in_class) {
+ in_class = false;
+ regexp += ch;
+ } else if (ch == "/" && !in_class) {
+ break;
+ } else if (ch == "\\") {
+ prev_backslash = true;
+ } else {
+ regexp += ch;
+ }
+ var mods = read_name();
+ return token("regexp", [ regexp, mods ]);
+ });
+ };
+
+ function read_operator(prefix) {
+ function grow(op) {
+ if (!peek()) return op;
+ var bigger = op + peek();
+ if (HOP(OPERATORS, bigger)) {
+ next();
+ return grow(bigger);
+ } else {
+ return op;
+ }
+ };
+ return token("operator", grow(prefix || next()));
+ };
+
+ function handle_slash() {
+ next();
+ var regex_allowed = S.regex_allowed;
+ switch (peek()) {
+ case "/":
+ S.comments_before.push(read_line_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ case "*":
+ S.comments_before.push(read_multiline_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ }
+ return S.regex_allowed ? read_regexp() : read_operator("/");
+ };
+
+ function handle_dot() {
+ next();
+ return is_digit(peek())
+ ? read_num(".")
+ : token("punc", ".");
+ };
+
+ function read_word() {
+ var word = read_name();
+ return !HOP(KEYWORDS, word)
+ ? token("name", word)
+ : HOP(OPERATORS, word)
+ ? token("operator", word)
+ : HOP(KEYWORDS_ATOM, word)
+ ? token("atom", word)
+ : token("keyword", word);
+ };
+
+ function with_eof_error(eof_error, cont) {
+ try {
+ return cont();
+ } catch(ex) {
+ if (ex === EX_EOF) parse_error(eof_error);
+ else throw ex;
+ }
+ };
+
+ function next_token(force_regexp) {
+ if (force_regexp)
+ return read_regexp();
+ skip_whitespace();
+ start_token();
+ var ch = peek();
+ if (!ch) return token("eof");
+ if (is_digit(ch)) return read_num();
+ if (ch == '"' || ch == "'") return read_string();
+ if (HOP(PUNC_CHARS, ch)) return token("punc", next());
+ if (ch == ".") return handle_dot();
+ if (ch == "/") return handle_slash();
+ if (HOP(OPERATOR_CHARS, ch)) return read_operator();
+ if (ch == "\\" || is_identifier_start(ch)) return read_word();
+ parse_error("Unexpected character '" + ch + "'");
+ };
+
+ next_token.context = function(nc) {
+ if (nc) S = nc;
+ return S;
+ };
+
+ return next_token;
+
+};
+
+/* -----[ Parser (constants) ]----- */
+
+var UNARY_PREFIX = array_to_hash([
+ "typeof",
+ "void",
+ "delete",
+ "--",
+ "++",
+ "!",
+ "~",
+ "-",
+ "+"
+]);
+
+var UNARY_POSTFIX = array_to_hash([ "--", "++" ]);
+
+var ASSIGNMENT = (function(a, ret, i){
+ while (i < a.length) {
+ ret[a[i]] = a[i].substr(0, a[i].length - 1);
+ i++;
+ }
+ return ret;
+})(
+ ["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="],
+ { "=": true },
+ 0
+);
+
+var PRECEDENCE = (function(a, ret){
+ for (var i = 0, n = 1; i < a.length; ++i, ++n) {
+ var b = a[i];
+ for (var j = 0; j < b.length; ++j) {
+ ret[b[j]] = n;
+ }
+ }
+ return ret;
+})(
+ [
+ ["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"]
+ ],
+ {}
+);
+
+var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
+
+var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+
+/* -----[ Parser ]----- */
+
+function NodeWithToken(str, start, end) {
+ this.name = str;
+ this.start = start;
+ this.end = end;
+};
+
+NodeWithToken.prototype.toString = function() { return this.name; };
+
+function parse($TEXT, exigent_mode, embed_tokens) {
+
+ var S = {
+ input : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
+ token : null,
+ prev : null,
+ peeked : null,
+ in_function : 0,
+ in_loop : 0,
+ labels : []
+ };
+
+ S.token = next();
+
+ function is(type, value) {
+ return is_token(S.token, type, value);
+ };
+
+ function peek() { return S.peeked || (S.peeked = S.input()); };
+
+ function next() {
+ S.prev = S.token;
+ if (S.peeked) {
+ S.token = S.peeked;
+ S.peeked = null;
+ } else {
+ S.token = S.input();
+ }
+ return S.token;
+ };
+
+ function prev() {
+ return S.prev;
+ };
+
+ function croak(msg, line, col, pos) {
+ var ctx = S.input.context();
+ js_error(msg,
+ line != null ? line : ctx.tokline,
+ col != null ? col : ctx.tokcol,
+ pos != null ? pos : ctx.tokpos);
+ };
+
+ function token_error(token, msg) {
+ croak(msg, token.line, token.col);
+ };
+
+ function unexpected(token) {
+ if (token == null)
+ token = S.token;
+ token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
+ };
+
+ function expect_token(type, val) {
+ if (is(type, val)) {
+ return next();
+ }
+ token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
+ };
+
+ function expect(punc) { return expect_token("punc", punc); };
+
+ function can_insert_semicolon() {
+ return !exigent_mode && (
+ S.token.nlb || is("eof") || is("punc", "}")
+ );
+ };
+
+ function semicolon() {
+ if (is("punc", ";")) next();
+ else if (!can_insert_semicolon()) unexpected();
+ };
+
+ function as() {
+ return slice(arguments);
+ };
+
+ function parenthesised() {
+ expect("(");
+ var ex = expression();
+ expect(")");
+ return ex;
+ };
+
+ function add_tokens(str, start, end) {
+ return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
+ };
+
+ function maybe_embed_tokens(parser) {
+ if (embed_tokens) return function() {
+ var start = S.token;
+ var ast = parser.apply(this, arguments);
+ ast[0] = add_tokens(ast[0], start, prev());
+ return ast;
+ };
+ else return parser;
+ };
+
+ var statement = maybe_embed_tokens(function() {
+ if (is("operator", "/")) {
+ S.peeked = null;
+ S.token = S.input(true); // force regexp
+ }
+ switch (S.token.type) {
+ case "num":
+ case "string":
+ case "regexp":
+ case "operator":
+ case "atom":
+ return simple_statement();
+
+ case "name":
+ return is_token(peek(), "punc", ":")
+ ? labeled_statement(prog1(S.token.value, next, next))
+ : simple_statement();
+
+ case "punc":
+ switch (S.token.value) {
+ case "{":
+ return as("block", block_());
+ case "[":
+ case "(":
+ return simple_statement();
+ case ";":
+ next();
+ return as("block");
+ default:
+ unexpected();
+ }
+
+ case "keyword":
+ switch (prog1(S.token.value, next)) {
+ case "break":
+ return break_cont("break");
+
+ case "continue":
+ return break_cont("continue");
+
+ case "debugger":
+ semicolon();
+ return as("debugger");
+
+ case "do":
+ return (function(body){
+ expect_token("keyword", "while");
+ return as("do", prog1(parenthesised, semicolon), body);
+ })(in_loop(statement));
+
+ case "for":
+ return for_();
+
+ case "function":
+ return function_(true);
+
+ case "if":
+ return if_();
+
+ case "return":
+ if (S.in_function == 0)
+ croak("'return' outside of function");
+ return as("return",
+ is("punc", ";")
+ ? (next(), null)
+ : can_insert_semicolon()
+ ? null
+ : prog1(expression, semicolon));
+
+ case "switch":
+ return as("switch", parenthesised(), switch_block_());
+
+ case "throw":
+ return as("throw", prog1(expression, semicolon));
+
+ case "try":
+ return try_();
+
+ case "var":
+ return prog1(var_, semicolon);
+
+ case "const":
+ return prog1(const_, semicolon);
+
+ case "while":
+ return as("while", parenthesised(), in_loop(statement));
+
+ case "with":
+ return as("with", parenthesised(), statement());
+
+ default:
+ unexpected();
+ }
+ }
+ });
+
+ function labeled_statement(label) {
+ S.labels.push(label);
+ var start = S.token, stat = statement();
+ if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
+ unexpected(start);
+ S.labels.pop();
+ return as("label", label, stat);
+ };
+
+ function simple_statement() {
+ return as("stat", prog1(expression, semicolon));
+ };
+
+ function break_cont(type) {
+ var name;
+ if (!can_insert_semicolon()) {
+ name = is("name") ? S.token.value : null;
+ }
+ if (name != null) {
+ next();
+ if (!member(name, S.labels))
+ croak("Label " + name + " without matching loop or statement");
+ }
+ else if (S.in_loop == 0)
+ croak(type + " not inside a loop or switch");
+ semicolon();
+ return as(type, name);
+ };
+
+ function for_() {
+ expect("(");
+ var init = null;
+ if (!is("punc", ";")) {
+ init = is("keyword", "var")
+ ? (next(), var_(true))
+ : expression(true, true);
+ if (is("operator", "in"))
+ return for_in(init);
+ }
+ return regular_for(init);
+ };
+
+ function regular_for(init) {
+ expect(";");
+ var test = is("punc", ";") ? null : expression();
+ expect(";");
+ var step = is("punc", ")") ? null : expression();
+ expect(")");
+ return as("for", init, test, step, in_loop(statement));
+ };
+
+ function for_in(init) {
+ var lhs = init[0] == "var" ? as("name", init[1][0]) : init;
+ next();
+ var obj = expression();
+ expect(")");
+ return as("for-in", init, lhs, obj, in_loop(statement));
+ };
+
+ var function_ = maybe_embed_tokens(function(in_statement) {
+ var name = is("name") ? prog1(S.token.value, next) : null;
+ if (in_statement && !name)
+ unexpected();
+ expect("(");
+ return as(in_statement ? "defun" : "function",
+ name,
+ // arguments
+ (function(first, a){
+ while (!is("punc", ")")) {
+ if (first) first = false; else expect(",");
+ if (!is("name")) unexpected();
+ a.push(S.token.value);
+ next();
+ }
+ next();
+ return a;
+ })(true, []),
+ // body
+ (function(){
+ ++S.in_function;
+ var loop = S.in_loop;
+ S.in_loop = 0;
+ var a = block_();
+ --S.in_function;
+ S.in_loop = loop;
+ return a;
+ })());
+ });
+
+ function if_() {
+ var cond = parenthesised(), body = statement(), belse;
+ if (is("keyword", "else")) {
+ next();
+ belse = statement();
+ }
+ return as("if", cond, body, belse);
+ };
+
+ function block_() {
+ expect("{");
+ var a = [];
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ a.push(statement());
+ }
+ next();
+ return a;
+ };
+
+ var switch_block_ = curry(in_loop, function(){
+ expect("{");
+ var a = [], cur = null;
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ if (is("keyword", "case")) {
+ next();
+ cur = [];
+ a.push([ expression(), cur ]);
+ expect(":");
+ }
+ else if (is("keyword", "default")) {
+ next();
+ expect(":");
+ cur = [];
+ a.push([ null, cur ]);
+ }
+ else {
+ if (!cur) unexpected();
+ cur.push(statement());
+ }
+ }
+ next();
+ return a;
+ });
+
+ function try_() {
+ var body = block_(), bcatch, bfinally;
+ if (is("keyword", "catch")) {
+ next();
+ expect("(");
+ if (!is("name"))
+ croak("Name expected");
+ var name = S.token.value;
+ next();
+ expect(")");
+ bcatch = [ name, block_() ];
+ }
+ if (is("keyword", "finally")) {
+ next();
+ bfinally = block_();
+ }
+ if (!bcatch && !bfinally)
+ croak("Missing catch/finally blocks");
+ return as("try", body, bcatch, bfinally);
+ };
+
+ function vardefs(no_in) {
+ var a = [];
+ for (;;) {
+ if (!is("name"))
+ unexpected();
+ var name = S.token.value;
+ next();
+ if (is("operator", "=")) {
+ next();
+ a.push([ name, expression(false, no_in) ]);
+ } else {
+ a.push([ name ]);
+ }
+ if (!is("punc", ","))
+ break;
+ next();
+ }
+ return a;
+ };
+
+ function var_(no_in) {
+ return as("var", vardefs(no_in));
+ };
+
+ function const_() {
+ return as("const", vardefs());
+ };
+
+ function new_() {
+ var newexp = expr_atom(false), args;
+ if (is("punc", "(")) {
+ next();
+ args = expr_list(")");
+ } else {
+ args = [];
+ }
+ return subscripts(as("new", newexp, args), true);
+ };
+
+ var expr_atom = maybe_embed_tokens(function(allow_calls) {
+ if (is("operator", "new")) {
+ next();
+ return new_();
+ }
+ if (is("punc")) {
+ switch (S.token.value) {
+ case "(":
+ next();
+ return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
+ case "[":
+ next();
+ return subscripts(array_(), allow_calls);
+ case "{":
+ next();
+ return subscripts(object_(), allow_calls);
+ }
+ unexpected();
+ }
+ if (is("keyword", "function")) {
+ next();
+ return subscripts(function_(false), allow_calls);
+ }
+ if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
+ var atom = S.token.type == "regexp"
+ ? as("regexp", S.token.value[0], S.token.value[1])
+ : as(S.token.type, S.token.value);
+ return subscripts(prog1(atom, next), allow_calls);
+ }
+ unexpected();
+ });
+
+ function expr_list(closing, allow_trailing_comma, allow_empty) {
+ var first = true, a = [];
+ while (!is("punc", closing)) {
+ if (first) first = false; else expect(",");
+ if (allow_trailing_comma && is("punc", closing)) break;
+ if (is("punc", ",") && allow_empty) {
+ a.push([ "atom", "undefined" ]);
+ } else {
+ a.push(expression(false));
+ }
+ }
+ next();
+ return a;
+ };
+
+ function array_() {
+ return as("array", expr_list("]", !exigent_mode, true));
+ };
+
+ function object_() {
+ var first = true, a = [];
+ while (!is("punc", "}")) {
+ if (first) first = false; else expect(",");
+ if (!exigent_mode && is("punc", "}"))
+ // allow trailing comma
+ break;
+ var type = S.token.type;
+ var name = as_property_name();
+ if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) {
+ a.push([ as_name(), function_(false), name ]);
+ } else {
+ expect(":");
+ a.push([ name, expression(false) ]);
+ }
+ }
+ next();
+ return as("object", a);
+ };
+
+ function as_property_name() {
+ switch (S.token.type) {
+ case "num":
+ case "string":
+ return prog1(S.token.value, next);
+ }
+ return as_name();
+ };
+
+ function as_name() {
+ switch (S.token.type) {
+ case "name":
+ case "operator":
+ case "keyword":
+ case "atom":
+ return prog1(S.token.value, next);
+ default:
+ unexpected();
+ }
+ };
+
+ function subscripts(expr, allow_calls) {
+ if (is("punc", ".")) {
+ next();
+ return subscripts(as("dot", expr, as_name()), allow_calls);
+ }
+ if (is("punc", "[")) {
+ next();
+ return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
+ }
+ if (allow_calls && is("punc", "(")) {
+ next();
+ return subscripts(as("call", expr, expr_list(")")), true);
+ }
+ return expr;
+ };
+
+ function maybe_unary(allow_calls) {
+ if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
+ return make_unary("unary-prefix",
+ prog1(S.token.value, next),
+ maybe_unary(allow_calls));
+ }
+ var val = expr_atom(allow_calls);
+ while (is("operator") && HOP(UNARY_POSTFIX, S.token.value) && !S.token.nlb) {
+ val = make_unary("unary-postfix", S.token.value, val);
+ next();
+ }
+ return val;
+ };
+
+ function make_unary(tag, op, expr) {
+ if ((op == "++" || op == "--") && !is_assignable(expr))
+ croak("Invalid use of " + op + " operator");
+ return as(tag, op, expr);
+ };
+
+ function expr_op(left, min_prec, no_in) {
+ var op = is("operator") ? S.token.value : null;
+ if (op && op == "in" && no_in) op = null;
+ var prec = op != null ? PRECEDENCE[op] : null;
+ if (prec != null && prec > min_prec) {
+ next();
+ var right = expr_op(maybe_unary(true), prec, no_in);
+ return expr_op(as("binary", op, left, right), min_prec, no_in);
+ }
+ return left;
+ };
+
+ function expr_ops(no_in) {
+ return expr_op(maybe_unary(true), 0, no_in);
+ };
+
+ function maybe_conditional(no_in) {
+ var expr = expr_ops(no_in);
+ if (is("operator", "?")) {
+ next();
+ var yes = expression(false);
+ expect(":");
+ return as("conditional", expr, yes, expression(false, no_in));
+ }
+ return expr;
+ };
+
+ function is_assignable(expr) {
+ if (!exigent_mode) return true;
+ switch (expr[0]) {
+ case "dot":
+ case "sub":
+ case "new":
+ case "call":
+ return true;
+ case "name":
+ return expr[1] != "this";
+ }
+ };
+
+ function maybe_assign(no_in) {
+ var left = maybe_conditional(no_in), val = S.token.value;
+ if (is("operator") && HOP(ASSIGNMENT, val)) {
+ if (is_assignable(left)) {
+ next();
+ return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in));
+ }
+ croak("Invalid assignment");
+ }
+ return left;
+ };
+
+ var expression = maybe_embed_tokens(function(commas, no_in) {
+ if (arguments.length == 0)
+ commas = true;
+ var expr = maybe_assign(no_in);
+ if (commas && is("punc", ",")) {
+ next();
+ return as("seq", expr, expression(true, no_in));
+ }
+ return expr;
+ });
+
+ function in_loop(cont) {
+ try {
+ ++S.in_loop;
+ return cont();
+ } finally {
+ --S.in_loop;
+ }
+ };
+
+ return as("toplevel", (function(a){
+ while (!is("eof"))
+ a.push(statement());
+ return a;
+ })([]));
+
+};
+
+/* -----[ Utilities ]----- */
+
+function curry(f) {
+ var args = slice(arguments, 1);
+ return function() { return f.apply(this, args.concat(slice(arguments))); };
+};
+
+function prog1(ret) {
+ if (ret instanceof Function)
+ ret = ret();
+ for (var i = 1, n = arguments.length; --n > 0; ++i)
+ arguments[i]();
+ return ret;
+};
+
+function array_to_hash(a) {
+ var ret = {};
+ for (var i = 0; i < a.length; ++i)
+ ret[a[i]] = true;
+ return ret;
+};
+
+function slice(a, start) {
+ return Array.prototype.slice.call(a, start == null ? 0 : start);
+};
+
+function characters(str) {
+ return str.split("");
+};
+
+function member(name, array) {
+ for (var i = array.length; --i >= 0;)
+ if (array[i] === name)
+ return true;
+ return false;
+};
+
+function HOP(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+var warn = function() {};
+
+/* -----[ Exports ]----- */
+
+exports.tokenizer = tokenizer;
+exports.parse = parse;
+exports.slice = slice;
+exports.curry = curry;
+exports.member = member;
+exports.array_to_hash = array_to_hash;
+exports.PRECEDENCE = PRECEDENCE;
+exports.KEYWORDS_ATOM = KEYWORDS_ATOM;
+exports.RESERVED_WORDS = RESERVED_WORDS;
+exports.KEYWORDS = KEYWORDS;
+exports.ATOMIC_START_TOKEN = ATOMIC_START_TOKEN;
+exports.OPERATORS = OPERATORS;
+exports.is_alphanumeric_char = is_alphanumeric_char;
+exports.set_logger = function(logger) {
+ warn = logger;
+};
--- /dev/null
+/***********************************************************************
+
+ A JavaScript tokenizer / parser / beautifier / compressor.
+
+ This version is suitable for Node.js. With minimal changes (the
+ exports stuff) it should work on any JS platform.
+
+ This file implements some AST processors. They work on data built
+ by parse-js.
+
+ Exported functions:
+
+ - ast_mangle(ast, options) -- mangles the variable/function names
+ in the AST. Returns an AST.
+
+ - ast_squeeze(ast) -- employs various optimizations to make the
+ final generated code even smaller. Returns an AST.
+
+ - gen_code(ast, options) -- generates JS code from the AST. Pass
+ true (or an object, see the code for some options) as second
+ argument to get "pretty" (indented) code.
+
+ -------------------------------- (C) ---------------------------------
+
+ Author: Mihai Bazon
+ <mihai.bazon@gmail.com>
+ http://mihai.bazon.net/blog
+
+ Distributed under the BSD license:
+
+ Copyright 2010 (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.
+
+ ***********************************************************************/
+
+var jsp = require("./parse-js"),
+ slice = jsp.slice,
+ member = jsp.member,
+ PRECEDENCE = jsp.PRECEDENCE,
+ OPERATORS = jsp.OPERATORS;
+
+/* -----[ helper for AST traversal ]----- */
+
+function ast_walker(ast) {
+ function _vardefs(defs) {
+ return [ this[0], MAP(defs, function(def){
+ var a = [ def[0] ];
+ if (def.length > 1)
+ a[1] = walk(def[1]);
+ return a;
+ }) ];
+ };
+ function _block(statements) {
+ var out = [ this[0] ];
+ if (statements != null)
+ out.push(MAP(statements, walk));
+ return out;
+ };
+ var walkers = {
+ "string": function(str) {
+ return [ this[0], str ];
+ },
+ "num": function(num) {
+ return [ this[0], num ];
+ },
+ "name": function(name) {
+ return [ this[0], name ];
+ },
+ "toplevel": function(statements) {
+ return [ this[0], MAP(statements, walk) ];
+ },
+ "block": _block,
+ "splice": _block,
+ "var": _vardefs,
+ "const": _vardefs,
+ "try": function(t, c, f) {
+ return [
+ this[0],
+ MAP(t, walk),
+ c != null ? [ c[0], MAP(c[1], walk) ] : null,
+ f != null ? MAP(f, walk) : null
+ ];
+ },
+ "throw": function(expr) {
+ return [ this[0], walk(expr) ];
+ },
+ "new": function(ctor, args) {
+ return [ this[0], walk(ctor), MAP(args, walk) ];
+ },
+ "switch": function(expr, body) {
+ return [ this[0], walk(expr), MAP(body, function(branch){
+ return [ branch[0] ? walk(branch[0]) : null,
+ MAP(branch[1], walk) ];
+ }) ];
+ },
+ "break": function(label) {
+ return [ this[0], label ];
+ },
+ "continue": function(label) {
+ return [ this[0], label ];
+ },
+ "conditional": function(cond, t, e) {
+ return [ this[0], walk(cond), walk(t), walk(e) ];
+ },
+ "assign": function(op, lvalue, rvalue) {
+ return [ this[0], op, walk(lvalue), walk(rvalue) ];
+ },
+ "dot": function(expr) {
+ return [ this[0], walk(expr) ].concat(slice(arguments, 1));
+ },
+ "call": function(expr, args) {
+ return [ this[0], walk(expr), MAP(args, walk) ];
+ },
+ "function": function(name, args, body) {
+ return [ this[0], name, args.slice(), MAP(body, walk) ];
+ },
+ "defun": function(name, args, body) {
+ return [ this[0], name, args.slice(), MAP(body, walk) ];
+ },
+ "if": function(conditional, t, e) {
+ return [ this[0], walk(conditional), walk(t), walk(e) ];
+ },
+ "for": function(init, cond, step, block) {
+ return [ this[0], walk(init), walk(cond), walk(step), walk(block) ];
+ },
+ "for-in": function(vvar, key, hash, block) {
+ return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ];
+ },
+ "while": function(cond, block) {
+ return [ this[0], walk(cond), walk(block) ];
+ },
+ "do": function(cond, block) {
+ return [ this[0], walk(cond), walk(block) ];
+ },
+ "return": function(expr) {
+ return [ this[0], walk(expr) ];
+ },
+ "binary": function(op, left, right) {
+ return [ this[0], op, walk(left), walk(right) ];
+ },
+ "unary-prefix": function(op, expr) {
+ return [ this[0], op, walk(expr) ];
+ },
+ "unary-postfix": function(op, expr) {
+ return [ this[0], op, walk(expr) ];
+ },
+ "sub": function(expr, subscript) {
+ return [ this[0], walk(expr), walk(subscript) ];
+ },
+ "object": function(props) {
+ return [ this[0], MAP(props, function(p){
+ return p.length == 2
+ ? [ p[0], walk(p[1]) ]
+ : [ p[0], walk(p[1]), p[2] ]; // get/set-ter
+ }) ];
+ },
+ "regexp": function(rx, mods) {
+ return [ this[0], rx, mods ];
+ },
+ "array": function(elements) {
+ return [ this[0], MAP(elements, walk) ];
+ },
+ "stat": function(stat) {
+ return [ this[0], walk(stat) ];
+ },
+ "seq": function() {
+ return [ this[0] ].concat(MAP(slice(arguments), walk));
+ },
+ "label": function(name, block) {
+ return [ this[0], name, walk(block) ];
+ },
+ "with": function(expr, block) {
+ return [ this[0], walk(expr), walk(block) ];
+ },
+ "atom": function(name) {
+ return [ this[0], name ];
+ }
+ };
+
+ var user = {};
+ var stack = [];
+ function walk(ast) {
+ if (ast == null)
+ return null;
+ try {
+ stack.push(ast);
+ var type = ast[0];
+ var gen = user[type];
+ if (gen) {
+ var ret = gen.apply(ast, ast.slice(1));
+ if (ret != null)
+ return ret;
+ }
+ gen = walkers[type];
+ return gen.apply(ast, ast.slice(1));
+ } finally {
+ stack.pop();
+ }
+ };
+
+ function with_walkers(walkers, cont){
+ var save = {}, i;
+ for (i in walkers) if (HOP(walkers, i)) {
+ save[i] = user[i];
+ user[i] = walkers[i];
+ }
+ var ret = cont();
+ for (i in save) if (HOP(save, i)) {
+ if (!save[i]) delete user[i];
+ else user[i] = save[i];
+ }
+ return ret;
+ };
+
+ return {
+ walk: walk,
+ with_walkers: with_walkers,
+ parent: function() {
+ return stack[stack.length - 2]; // last one is current node
+ },
+ stack: function() {
+ return stack;
+ }
+ };
+};
+
+/* -----[ Scope and mangling ]----- */
+
+function Scope(parent) {
+ this.names = {}; // names defined in this scope
+ this.mangled = {}; // mangled names (orig.name => mangled)
+ this.rev_mangled = {}; // reverse lookup (mangled => orig.name)
+ this.cname = -1; // current mangled name
+ this.refs = {}; // names referenced from this scope
+ this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes
+ this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes
+ this.parent = parent; // parent scope
+ this.children = []; // sub-scopes
+ if (parent) {
+ this.level = parent.level + 1;
+ parent.children.push(this);
+ } else {
+ this.level = 0;
+ }
+};
+
+var base54 = (function(){
+ var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_";
+ return function(num) {
+ var ret = "";
+ do {
+ ret = DIGITS.charAt(num % 54) + ret;
+ num = Math.floor(num / 54);
+ } while (num > 0);
+ return ret;
+ };
+})();
+
+Scope.prototype = {
+ has: function(name) {
+ for (var s = this; s; s = s.parent)
+ if (HOP(s.names, name))
+ return s;
+ },
+ has_mangled: function(mname) {
+ for (var s = this; s; s = s.parent)
+ if (HOP(s.rev_mangled, mname))
+ return s;
+ },
+ toJSON: function() {
+ return {
+ names: this.names,
+ uses_eval: this.uses_eval,
+ uses_with: this.uses_with
+ };
+ },
+
+ next_mangled: function() {
+ // we must be careful that the new mangled name:
+ //
+ // 1. doesn't shadow a mangled name from a parent
+ // scope, unless we don't reference the original
+ // name from this scope OR from any sub-scopes!
+ // This will get slow.
+ //
+ // 2. doesn't shadow an original name from a parent
+ // scope, in the event that the name is not mangled
+ // in the parent scope and we reference that name
+ // here OR IN ANY SUBSCOPES!
+ //
+ // 3. doesn't shadow a name that is referenced but not
+ // defined (possibly global defined elsewhere).
+ for (;;) {
+ var m = base54(++this.cname), prior;
+
+ // case 1.
+ prior = this.has_mangled(m);
+ if (prior && this.refs[prior.rev_mangled[m]] === prior)
+ continue;
+
+ // case 2.
+ prior = this.has(m);
+ if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m))
+ continue;
+
+ // case 3.
+ if (HOP(this.refs, m) && this.refs[m] == null)
+ continue;
+
+ // I got "do" once. :-/
+ if (!is_identifier(m))
+ continue;
+
+ return m;
+ }
+ },
+ set_mangle: function(name, m) {
+ this.rev_mangled[m] = name;
+ return this.mangled[name] = m;
+ },
+ get_mangled: function(name, newMangle) {
+ if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use
+ var s = this.has(name);
+ if (!s) return name; // not in visible scope, no mangle
+ if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope
+ if (!newMangle) return name; // not found and no mangling requested
+ return s.set_mangle(name, s.next_mangled());
+ },
+ define: function(name) {
+ if (name != null)
+ return this.names[name] = name;
+ }
+};
+
+function ast_add_scope(ast) {
+
+ var current_scope = null;
+ var w = ast_walker(), walk = w.walk;
+ var having_eval = [];
+
+ function with_new_scope(cont) {
+ current_scope = new Scope(current_scope);
+ var ret = current_scope.body = cont();
+ ret.scope = current_scope;
+ current_scope = current_scope.parent;
+ return ret;
+ };
+
+ function define(name) {
+ return current_scope.define(name);
+ };
+
+ function reference(name) {
+ current_scope.refs[name] = true;
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun";
+ return [ this[0], is_defun ? define(name) : name, args, with_new_scope(function(){
+ if (!is_defun) define(name);
+ MAP(args, define);
+ return MAP(body, walk);
+ })];
+ };
+
+ return with_new_scope(function(){
+ // process AST
+ var ret = w.with_walkers({
+ "function": _lambda,
+ "defun": _lambda,
+ "with": function(expr, block) {
+ for (var s = current_scope; s; s = s.parent)
+ s.uses_with = true;
+ },
+ "var": function(defs) {
+ MAP(defs, function(d){ define(d[0]) });
+ },
+ "const": function(defs) {
+ MAP(defs, function(d){ define(d[0]) });
+ },
+ "try": function(t, c, f) {
+ if (c != null) return [
+ this[0],
+ MAP(t, walk),
+ [ define(c[0]), MAP(c[1], walk) ],
+ f != null ? MAP(f, walk) : null
+ ];
+ },
+ "name": function(name) {
+ if (name == "eval")
+ having_eval.push(current_scope);
+ reference(name);
+ }
+ }, function(){
+ return walk(ast);
+ });
+
+ // the reason why we need an additional pass here is
+ // that names can be used prior to their definition.
+
+ // scopes where eval was detected and their parents
+ // are marked with uses_eval, unless they define the
+ // "eval" name.
+ MAP(having_eval, function(scope){
+ if (!scope.has("eval")) while (scope) {
+ scope.uses_eval = true;
+ scope = scope.parent;
+ }
+ });
+
+ // for referenced names it might be useful to know
+ // their origin scope. current_scope here is the
+ // toplevel one.
+ function fixrefs(scope, i) {
+ // do children first; order shouldn't matter
+ for (i = scope.children.length; --i >= 0;)
+ fixrefs(scope.children[i]);
+ for (i in scope.refs) if (HOP(scope.refs, i)) {
+ // find origin scope and propagate the reference to origin
+ for (var origin = scope.has(i), s = scope; s; s = s.parent) {
+ s.refs[i] = origin;
+ if (s === origin) break;
+ }
+ }
+ };
+ fixrefs(current_scope);
+
+ return ret;
+ });
+
+};
+
+/* -----[ mangle names ]----- */
+
+function ast_mangle(ast, options) {
+ var w = ast_walker(), walk = w.walk, scope;
+ options = options || {};
+
+ function get_mangled(name, newMangle) {
+ if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel
+ if (options.except && member(name, options.except))
+ return name;
+ return scope.get_mangled(name, newMangle);
+ };
+
+ function get_define(name) {
+ if (options.defines) {
+ // we always lookup a defined symbol for the current scope FIRST, so declared
+ // vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value
+ if (!scope.has(name)) {
+ if (HOP(options.defines, name)) {
+ return options.defines[name];
+ }
+ }
+ return null;
+ }
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun", extra;
+ if (name) {
+ if (is_defun) name = get_mangled(name);
+ else {
+ extra = {};
+ if (!(scope.uses_eval || scope.uses_with))
+ name = extra[name] = scope.next_mangled();
+ else
+ extra[name] = name;
+ }
+ }
+ body = with_scope(body.scope, function(){
+ args = MAP(args, function(name){ return get_mangled(name) });
+ return MAP(body, walk);
+ }, extra);
+ return [ this[0], name, args, body ];
+ };
+
+ function with_scope(s, cont, extra) {
+ var _scope = scope;
+ scope = s;
+ if (extra) for (var i in extra) if (HOP(extra, i)) {
+ s.set_mangle(i, extra[i]);
+ }
+ for (var i in s.names) if (HOP(s.names, i)) {
+ get_mangled(i, true);
+ }
+ var ret = cont();
+ ret.scope = s;
+ scope = _scope;
+ return ret;
+ };
+
+ function _vardefs(defs) {
+ return [ this[0], MAP(defs, function(d){
+ return [ get_mangled(d[0]), walk(d[1]) ];
+ }) ];
+ };
+
+ return w.with_walkers({
+ "function": _lambda,
+ "defun": function() {
+ // move function declarations to the top when
+ // they are not in some block.
+ var ast = _lambda.apply(this, arguments);
+ switch (w.parent()[0]) {
+ case "toplevel":
+ case "function":
+ case "defun":
+ return MAP.at_top(ast);
+ }
+ return ast;
+ },
+ "var": _vardefs,
+ "const": _vardefs,
+ "name": function(name) {
+ return get_define(name) || [ this[0], get_mangled(name) ];
+ },
+ "try": function(t, c, f) {
+ return [ this[0],
+ MAP(t, walk),
+ c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null,
+ f != null ? MAP(f, walk) : null ];
+ },
+ "toplevel": function(body) {
+ var self = this;
+ return with_scope(self.scope, function(){
+ return [ self[0], MAP(body, walk) ];
+ });
+ }
+ }, function() {
+ return walk(ast_add_scope(ast));
+ });
+};
+
+/* -----[
+ - compress foo["bar"] into foo.bar,
+ - remove block brackets {} where possible
+ - join consecutive var declarations
+ - various optimizations for IFs:
+ - if (cond) foo(); else bar(); ==> cond?foo():bar();
+ - if (cond) foo(); ==> cond&&foo();
+ - if (foo) return bar(); else return baz(); ==> return foo?bar():baz(); // also for throw
+ - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+ ]----- */
+
+var warn = function(){};
+
+function best_of(ast1, ast2) {
+ return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1;
+};
+
+function last_stat(b) {
+ if (b[0] == "block" && b[1] && b[1].length > 0)
+ return b[1][b[1].length - 1];
+ return b;
+}
+
+function aborts(t) {
+ if (t) {
+ t = last_stat(t);
+ if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw")
+ return true;
+ }
+};
+
+function boolean_expr(expr) {
+ return ( (expr[0] == "unary-prefix"
+ && member(expr[1], [ "!", "delete" ])) ||
+
+ (expr[0] == "binary"
+ && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) ||
+
+ (expr[0] == "binary"
+ && member(expr[1], [ "&&", "||" ])
+ && boolean_expr(expr[2])
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "conditional"
+ && boolean_expr(expr[2])
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "assign"
+ && expr[1] === true
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "seq"
+ && boolean_expr(expr[expr.length - 1]))
+ );
+};
+
+function make_conditional(c, t, e) {
+ var make_real_conditional = function() {
+ if (c[0] == "unary-prefix" && c[1] == "!") {
+ return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ];
+ } else {
+ return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ];
+ }
+ };
+ // shortcut the conditional if the expression has a constant value
+ return when_constant(c, function(ast, val){
+ warn_unreachable(val ? e : t);
+ return (val ? t : e);
+ }, make_real_conditional);
+};
+
+function empty(b) {
+ return !b || (b[0] == "block" && (!b[1] || b[1].length == 0));
+};
+
+function is_string(node) {
+ return (node[0] == "string" ||
+ node[0] == "unary-prefix" && node[1] == "typeof" ||
+ node[0] == "binary" && node[1] == "+" &&
+ (is_string(node[2]) || is_string(node[3])));
+};
+
+var when_constant = (function(){
+
+ var $NOT_CONSTANT = {};
+
+ // this can only evaluate constant expressions. If it finds anything
+ // not constant, it throws $NOT_CONSTANT.
+ function evaluate(expr) {
+ switch (expr[0]) {
+ case "string":
+ case "num":
+ return expr[1];
+ case "name":
+ case "atom":
+ switch (expr[1]) {
+ case "true": return true;
+ case "false": return false;
+ }
+ break;
+ case "unary-prefix":
+ switch (expr[1]) {
+ case "!": return !evaluate(expr[2]);
+ case "typeof": return typeof evaluate(expr[2]);
+ case "~": return ~evaluate(expr[2]);
+ case "-": return -evaluate(expr[2]);
+ case "+": return +evaluate(expr[2]);
+ }
+ break;
+ case "binary":
+ var left = expr[2], right = expr[3];
+ switch (expr[1]) {
+ case "&&" : return evaluate(left) && evaluate(right);
+ case "||" : return evaluate(left) || evaluate(right);
+ case "|" : return evaluate(left) | evaluate(right);
+ case "&" : return evaluate(left) & evaluate(right);
+ case "^" : return evaluate(left) ^ evaluate(right);
+ case "+" : return evaluate(left) + evaluate(right);
+ case "*" : return evaluate(left) * evaluate(right);
+ case "/" : return evaluate(left) / evaluate(right);
+ case "-" : return evaluate(left) - evaluate(right);
+ case "<<" : return evaluate(left) << evaluate(right);
+ case ">>" : return evaluate(left) >> evaluate(right);
+ case ">>>" : return evaluate(left) >>> evaluate(right);
+ case "==" : return evaluate(left) == evaluate(right);
+ case "===" : return evaluate(left) === evaluate(right);
+ case "!=" : return evaluate(left) != evaluate(right);
+ case "!==" : return evaluate(left) !== evaluate(right);
+ case "<" : return evaluate(left) < evaluate(right);
+ case "<=" : return evaluate(left) <= evaluate(right);
+ case ">" : return evaluate(left) > evaluate(right);
+ case ">=" : return evaluate(left) >= evaluate(right);
+ case "in" : return evaluate(left) in evaluate(right);
+ case "instanceof" : return evaluate(left) instanceof evaluate(right);
+ }
+ }
+ throw $NOT_CONSTANT;
+ };
+
+ return function(expr, yes, no) {
+ try {
+ var val = evaluate(expr), ast;
+ switch (typeof val) {
+ case "string": ast = [ "string", val ]; break;
+ case "number": ast = [ "num", val ]; break;
+ case "boolean": ast = [ "name", String(val) ]; break;
+ default: throw new Error("Can't handle constant of type: " + (typeof val));
+ }
+ return yes.call(expr, ast, val);
+ } catch(ex) {
+ if (ex === $NOT_CONSTANT) {
+ if (expr[0] == "binary"
+ && (expr[1] == "===" || expr[1] == "!==")
+ && ((is_string(expr[2]) && is_string(expr[3]))
+ || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) {
+ expr[1] = expr[1].substr(0, 2);
+ }
+ else if (no && expr[0] == "binary"
+ && (expr[1] == "||" || expr[1] == "&&")) {
+ // the whole expression is not constant but the lval may be...
+ try {
+ var lval = evaluate(expr[2]);
+ expr = ((expr[1] == "&&" && (lval ? expr[3] : lval)) ||
+ (expr[1] == "||" && (lval ? lval : expr[3])) ||
+ expr);
+ } catch(ex2) {
+ // IGNORE... lval is not constant
+ }
+ }
+ return no ? no.call(expr, expr) : null;
+ }
+ else throw ex;
+ }
+ };
+
+})();
+
+function warn_unreachable(ast) {
+ if (!empty(ast))
+ warn("Dropping unreachable code: " + gen_code(ast, true));
+};
+
+function prepare_ifs(ast) {
+ var w = ast_walker(), walk = w.walk;
+ // In this first pass, we rewrite ifs which abort with no else with an
+ // if-else. For example:
+ //
+ // if (x) {
+ // blah();
+ // return y;
+ // }
+ // foobar();
+ //
+ // is rewritten into:
+ //
+ // if (x) {
+ // blah();
+ // return y;
+ // } else {
+ // foobar();
+ // }
+ function redo_if(statements) {
+ statements = MAP(statements, walk);
+
+ for (var i = 0; i < statements.length; ++i) {
+ var fi = statements[i];
+ if (fi[0] != "if") continue;
+
+ if (fi[3] && walk(fi[3])) continue;
+
+ var t = walk(fi[2]);
+ if (!aborts(t)) continue;
+
+ var conditional = walk(fi[1]);
+
+ var e_body = statements.slice(i + 1);
+ var e;
+ if (e_body.length == 1) e = e_body[0];
+ else e = [ "block", e_body ];
+
+ var ret = statements.slice(0, i).concat([ [
+ fi[0], // "if"
+ conditional, // conditional
+ t, // then
+ e // else
+ ] ]);
+
+ return redo_if(ret);
+ }
+
+ return statements;
+ };
+
+ function redo_if_lambda(name, args, body) {
+ body = redo_if(body);
+ return [ this[0], name, args.slice(), body ];
+ };
+
+ function redo_if_block(statements) {
+ var out = [ this[0] ];
+ if (statements != null)
+ out.push(redo_if(statements));
+ return out;
+ };
+
+ return w.with_walkers({
+ "defun": redo_if_lambda,
+ "function": redo_if_lambda,
+ "block": redo_if_block,
+ "splice": redo_if_block,
+ "toplevel": function(statements) {
+ return [ this[0], redo_if(statements) ];
+ },
+ "try": function(t, c, f) {
+ return [
+ this[0],
+ redo_if(t),
+ c != null ? [ c[0], redo_if(c[1]) ] : null,
+ f != null ? redo_if(f) : null
+ ];
+ }
+ }, function() {
+ return walk(ast);
+ });
+};
+
+function ast_squeeze(ast, options) {
+ options = defaults(options, {
+ make_seqs : true,
+ dead_code : true,
+ keep_comps : true,
+ no_warnings : false
+ });
+
+ var w = ast_walker(), walk = w.walk, scope;
+
+ function negate(c) {
+ var not_c = [ "unary-prefix", "!", c ];
+ switch (c[0]) {
+ case "unary-prefix":
+ return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c;
+ case "seq":
+ c = slice(c);
+ c[c.length - 1] = negate(c[c.length - 1]);
+ return c;
+ case "conditional":
+ return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]);
+ case "binary":
+ var op = c[1], left = c[2], right = c[3];
+ if (!options.keep_comps) switch (op) {
+ case "<=" : return [ "binary", ">", left, right ];
+ case "<" : return [ "binary", ">=", left, right ];
+ case ">=" : return [ "binary", "<", left, right ];
+ case ">" : return [ "binary", "<=", left, right ];
+ }
+ switch (op) {
+ case "==" : return [ "binary", "!=", left, right ];
+ case "!=" : return [ "binary", "==", left, right ];
+ case "===" : return [ "binary", "!==", left, right ];
+ case "!==" : return [ "binary", "===", left, right ];
+ case "&&" : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]);
+ case "||" : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]);
+ }
+ break;
+ }
+ return not_c;
+ };
+
+ function with_scope(s, cont) {
+ var _scope = scope;
+ scope = s;
+ var ret = cont();
+ ret.scope = s;
+ scope = _scope;
+ return ret;
+ };
+
+ function rmblock(block) {
+ if (block != null && block[0] == "block" && block[1]) {
+ if (block[1].length == 1)
+ block = block[1][0];
+ else if (block[1].length == 0)
+ block = [ "block" ];
+ }
+ return block;
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun";
+ body = with_scope(body.scope, function(){
+ var ret = tighten(MAP(body, walk), "lambda");
+ if (!is_defun && name && !HOP(scope.refs, name))
+ name = null;
+ return ret;
+ });
+ return [ this[0], name, args, body ];
+ };
+
+ // we get here for blocks that have been already transformed.
+ // this function does a few things:
+ // 1. discard useless blocks
+ // 2. join consecutive var declarations
+ // 3. remove obviously dead code
+ // 4. transform consecutive statements using the comma operator
+ // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
+ function tighten(statements, block_type) {
+ statements = statements.reduce(function(a, stat){
+ if (stat[0] == "block") {
+ if (stat[1]) {
+ a.push.apply(a, stat[1]);
+ }
+ } else {
+ a.push(stat);
+ }
+ return a;
+ }, []);
+
+ statements = (function(a, prev){
+ statements.forEach(function(cur){
+ if (prev && ((cur[0] == "var" && prev[0] == "var") ||
+ (cur[0] == "const" && prev[0] == "const"))) {
+ prev[1] = prev[1].concat(cur[1]);
+ } else {
+ a.push(cur);
+ prev = cur;
+ }
+ });
+ return a;
+ })([]);
+
+ if (options.dead_code) statements = (function(a, has_quit){
+ statements.forEach(function(st){
+ if (has_quit) {
+ if (member(st[0], [ "function", "defun" , "var", "const" ])) {
+ a.push(st);
+ }
+ else if (!options.no_warnings)
+ warn_unreachable(st);
+ }
+ else {
+ a.push(st);
+ if (member(st[0], [ "return", "throw", "break", "continue" ]))
+ has_quit = true;
+ }
+ });
+ return a;
+ })([]);
+
+ if (options.make_seqs) statements = (function(a, prev) {
+ statements.forEach(function(cur){
+ if (prev && prev[0] == "stat" && cur[0] == "stat") {
+ prev[1] = [ "seq", prev[1], cur[1] ];
+ } else {
+ a.push(cur);
+ prev = cur;
+ }
+ });
+ return a;
+ })([]);
+
+ if (block_type == "lambda") statements = (function(i, a, stat){
+ while (i < statements.length) {
+ stat = statements[i++];
+ if (stat[0] == "if" && !stat[3]) {
+ if (stat[2][0] == "return" && stat[2][1] == null) {
+ a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
+ break;
+ }
+ var last = last_stat(stat[2]);
+ if (last[0] == "return" && last[1] == null) {
+ a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
+ break;
+ }
+ }
+ a.push(stat);
+ }
+ return a;
+ })(0, []);
+
+ return statements;
+ };
+
+ function make_if(c, t, e) {
+ return when_constant(c, function(ast, val){
+ if (val) {
+ warn_unreachable(e);
+ return t;
+ } else {
+ warn_unreachable(t);
+ return e;
+ }
+ }, function() {
+ return make_real_if(c, t, e);
+ });
+ };
+
+ function make_real_if(c, t, e) {
+ c = walk(c);
+ t = walk(t);
+ e = walk(e);
+
+ if (empty(t)) {
+ c = negate(c);
+ t = e;
+ e = null;
+ } else if (empty(e)) {
+ e = null;
+ } else {
+ // if we have both else and then, maybe it makes sense to switch them?
+ (function(){
+ var a = gen_code(c);
+ var n = negate(c);
+ var b = gen_code(n);
+ if (b.length < a.length) {
+ var tmp = t;
+ t = e;
+ e = tmp;
+ c = n;
+ }
+ })();
+ }
+ if (empty(e) && empty(t))
+ return [ "stat", c ];
+ var ret = [ "if", c, t, e ];
+ if (t[0] == "if" && empty(t[3]) && empty(e)) {
+ ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ]));
+ }
+ else if (t[0] == "stat") {
+ if (e) {
+ if (e[0] == "stat") {
+ ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]);
+ }
+ }
+ else {
+ ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]);
+ }
+ }
+ else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) {
+ ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]);
+ }
+ else if (e && aborts(t)) {
+ ret = [ [ "if", c, t ] ];
+ if (e[0] == "block") {
+ if (e[1]) ret = ret.concat(e[1]);
+ }
+ else {
+ ret.push(e);
+ }
+ ret = walk([ "block", ret ]);
+ }
+ else if (t && aborts(e)) {
+ ret = [ [ "if", negate(c), e ] ];
+ if (t[0] == "block") {
+ if (t[1]) ret = ret.concat(t[1]);
+ } else {
+ ret.push(t);
+ }
+ ret = walk([ "block", ret ]);
+ }
+ return ret;
+ };
+
+ function _do_while(cond, body) {
+ return when_constant(cond, function(cond, val){
+ if (!val) {
+ warn_unreachable(body);
+ return [ "block" ];
+ } else {
+ return [ "for", null, null, null, walk(body) ];
+ }
+ });
+ };
+
+ ast = prepare_ifs(ast);
+ ast = ast_add_scope(ast);
+
+ return w.with_walkers({
+ "sub": function(expr, subscript) {
+ if (subscript[0] == "string") {
+ var name = subscript[1];
+ if (is_identifier(name))
+ return [ "dot", walk(expr), name ];
+ else if (/^[1-9][0-9]*$/.test(name) || name === "0")
+ return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ];
+ }
+ },
+ "if": make_if,
+ "toplevel": function(body) {
+ return [ "toplevel", with_scope(this.scope, function(){
+ return tighten(MAP(body, walk));
+ }) ];
+ },
+ "switch": function(expr, body) {
+ var last = body.length - 1;
+ return [ "switch", walk(expr), MAP(body, function(branch, i){
+ var block = tighten(MAP(branch[1], walk));
+ if (i == last && block.length > 0) {
+ var node = block[block.length - 1];
+ if (node[0] == "break" && !node[1])
+ block.pop();
+ }
+ return [ branch[0] ? walk(branch[0]) : null, block ];
+ }) ];
+ },
+ "function": _lambda,
+ "defun": _lambda,
+ "block": function(body) {
+ if (body) return rmblock([ "block", tighten(MAP(body, walk)) ]);
+ },
+ "binary": function(op, left, right) {
+ return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){
+ return best_of(walk(c), this);
+ }, function no() {
+ return this;
+ });
+ },
+ "conditional": function(c, t, e) {
+ return make_conditional(walk(c), walk(t), walk(e));
+ },
+ "try": function(t, c, f) {
+ return [
+ "try",
+ tighten(MAP(t, walk)),
+ c != null ? [ c[0], tighten(MAP(c[1], walk)) ] : null,
+ f != null ? tighten(MAP(f, walk)) : null
+ ];
+ },
+ "unary-prefix": function(op, expr) {
+ expr = walk(expr);
+ var ret = [ "unary-prefix", op, expr ];
+ if (op == "!")
+ ret = best_of(ret, negate(expr));
+ return when_constant(ret, function(ast, val){
+ return walk(ast); // it's either true or false, so minifies to !0 or !1
+ }, function() { return ret });
+ },
+ "name": function(name) {
+ switch (name) {
+ case "true": return [ "unary-prefix", "!", [ "num", 0 ]];
+ case "false": return [ "unary-prefix", "!", [ "num", 1 ]];
+ }
+ },
+ "new": function(ctor, args) {
+ if (ctor[0] == "name" && ctor[1] == "Array" && !scope.has("Array")) {
+ if (args.length != 1) {
+ return [ "array", args ];
+ } else {
+ return [ "call", [ "name", "Array" ], args ];
+ }
+ }
+ },
+ "call": function(expr, args) {
+ if (expr[0] == "name" && expr[1] == "Array" && args.length != 1 && !scope.has("Array")) {
+ return [ "array", args ];
+ }
+ },
+ "while": _do_while
+ }, function() {
+ return walk(ast);
+ });
+};
+
+/* -----[ re-generate code from the AST ]----- */
+
+var DOT_CALL_NO_PARENS = jsp.array_to_hash([
+ "name",
+ "array",
+ "object",
+ "string",
+ "dot",
+ "sub",
+ "call",
+ "regexp"
+]);
+
+function make_string(str, ascii_only) {
+ var dq = 0, sq = 0;
+ str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){
+ switch (s) {
+ case "\\": return "\\\\";
+ case "\b": return "\\b";
+ case "\f": return "\\f";
+ case "\n": return "\\n";
+ case "\r": return "\\r";
+ case "\t": return "\\t";
+ case "\u2028": return "\\u2028";
+ case "\u2029": return "\\u2029";
+ case '"': ++dq; return '"';
+ case "'": ++sq; return "'";
+ }
+ return s;
+ });
+ if (ascii_only) str = to_ascii(str);
+ if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'";
+ else return '"' + str.replace(/\x22/g, '\\"') + '"';
+};
+
+function to_ascii(str) {
+ return str.replace(/[\u0080-\uffff]/g, function(ch) {
+ var code = ch.charCodeAt(0).toString(16);
+ while (code.length < 4) code = "0" + code;
+ return "\\u" + code;
+ });
+};
+
+var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]);
+
+function gen_code(ast, options) {
+ options = defaults(options, {
+ indent_start : 0,
+ indent_level : 4,
+ quote_keys : false,
+ space_colon : false,
+ beautify : false,
+ ascii_only : false,
+ inline_script: false
+ });
+ var beautify = !!options.beautify;
+ var indentation = 0,
+ newline = beautify ? "\n" : "",
+ space = beautify ? " " : "";
+
+ function encode_string(str) {
+ var ret = make_string(str, options.ascii_only);
+ if (options.inline_script)
+ ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1");
+ return ret;
+ };
+
+ function make_name(name) {
+ name = name.toString();
+ if (options.ascii_only)
+ name = to_ascii(name);
+ return name;
+ };
+
+ function indent(line) {
+ if (line == null)
+ line = "";
+ if (beautify)
+ line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line;
+ return line;
+ };
+
+ function with_indent(cont, incr) {
+ if (incr == null) incr = 1;
+ indentation += incr;
+ try { return cont.apply(null, slice(arguments, 1)); }
+ finally { indentation -= incr; }
+ };
+
+ function add_spaces(a) {
+ if (beautify)
+ return a.join(" ");
+ var b = [];
+ for (var i = 0; i < a.length; ++i) {
+ var next = a[i + 1];
+ b.push(a[i]);
+ if (next &&
+ ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) ||
+ (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) {
+ b.push(" ");
+ }
+ }
+ return b.join("");
+ };
+
+ function add_commas(a) {
+ return a.join("," + space);
+ };
+
+ function parenthesize(expr) {
+ var gen = make(expr);
+ for (var i = 1; i < arguments.length; ++i) {
+ var el = arguments[i];
+ if ((el instanceof Function && el(expr)) || expr[0] == el)
+ return "(" + gen + ")";
+ }
+ return gen;
+ };
+
+ function best_of(a) {
+ if (a.length == 1) {
+ return a[0];
+ }
+ if (a.length == 2) {
+ var b = a[1];
+ a = a[0];
+ return a.length <= b.length ? a : b;
+ }
+ return best_of([ a[0], best_of(a.slice(1)) ]);
+ };
+
+ function needs_parens(expr) {
+ if (expr[0] == "function" || expr[0] == "object") {
+ // dot/call on a literal function requires the
+ // function literal itself to be parenthesized
+ // only if it's the first "thing" in a
+ // statement. This means that the parent is
+ // "stat", but it could also be a "seq" and
+ // we're the first in this "seq" and the
+ // parent is "stat", and so on. Messy stuff,
+ // but it worths the trouble.
+ var a = slice($stack), self = a.pop(), p = a.pop();
+ while (p) {
+ if (p[0] == "stat") return true;
+ if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) ||
+ ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) {
+ self = p;
+ p = a.pop();
+ } else {
+ return false;
+ }
+ }
+ }
+ return !HOP(DOT_CALL_NO_PARENS, expr[0]);
+ };
+
+ function make_num(num) {
+ var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m;
+ if (Math.floor(num) === num) {
+ a.push("0x" + num.toString(16).toLowerCase(), // probably pointless
+ "0" + num.toString(8)); // same.
+ if ((m = /^(.*?)(0+)$/.exec(num))) {
+ a.push(m[1] + "e" + m[2].length);
+ }
+ } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
+ a.push(m[2] + "e-" + (m[1].length + m[2].length),
+ str.substr(str.indexOf(".")));
+ }
+ return best_of(a);
+ };
+
+ var generators = {
+ "string": encode_string,
+ "num": make_num,
+ "name": make_name,
+ "toplevel": function(statements) {
+ return make_block_statements(statements)
+ .join(newline + newline);
+ },
+ "splice": function(statements) {
+ var parent = $stack[$stack.length - 2][0];
+ if (HOP(SPLICE_NEEDS_BRACKETS, parent)) {
+ // we need block brackets in this case
+ return make_block.apply(this, arguments);
+ } else {
+ return MAP(make_block_statements(statements, true),
+ function(line, i) {
+ // the first line is already indented
+ return i > 0 ? indent(line) : line;
+ }).join(newline);
+ }
+ },
+ "block": make_block,
+ "var": function(defs) {
+ return "var " + add_commas(MAP(defs, make_1vardef)) + ";";
+ },
+ "const": function(defs) {
+ return "const " + add_commas(MAP(defs, make_1vardef)) + ";";
+ },
+ "try": function(tr, ca, fi) {
+ var out = [ "try", make_block(tr) ];
+ if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1]));
+ if (fi) out.push("finally", make_block(fi));
+ return add_spaces(out);
+ },
+ "throw": function(expr) {
+ return add_spaces([ "throw", make(expr) ]) + ";";
+ },
+ "new": function(ctor, args) {
+ args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : "";
+ return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){
+ var w = ast_walker(), has_call = {};
+ try {
+ w.with_walkers({
+ "call": function() { throw has_call },
+ "function": function() { return this }
+ }, function(){
+ w.walk(expr);
+ });
+ } catch(ex) {
+ if (ex === has_call)
+ return true;
+ throw ex;
+ }
+ }) + args ]);
+ },
+ "switch": function(expr, body) {
+ return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]);
+ },
+ "break": function(label) {
+ var out = "break";
+ if (label != null)
+ out += " " + make_name(label);
+ return out + ";";
+ },
+ "continue": function(label) {
+ var out = "continue";
+ if (label != null)
+ out += " " + make_name(label);
+ return out + ";";
+ },
+ "conditional": function(co, th, el) {
+ return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?",
+ parenthesize(th, "seq"), ":",
+ parenthesize(el, "seq") ]);
+ },
+ "assign": function(op, lvalue, rvalue) {
+ if (op && op !== true) op += "=";
+ else op = "=";
+ return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]);
+ },
+ "dot": function(expr) {
+ var out = make(expr), i = 1;
+ if (expr[0] == "num") {
+ if (!/\./.test(expr[1]))
+ out += ".";
+ } else if (needs_parens(expr))
+ out = "(" + out + ")";
+ while (i < arguments.length)
+ out += "." + make_name(arguments[i++]);
+ return out;
+ },
+ "call": function(func, args) {
+ var f = make(func);
+ if (needs_parens(func))
+ f = "(" + f + ")";
+ return f + "(" + add_commas(MAP(args, function(expr){
+ return parenthesize(expr, "seq");
+ })) + ")";
+ },
+ "function": make_function,
+ "defun": make_function,
+ "if": function(co, th, el) {
+ var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ];
+ if (el) {
+ out.push("else", make(el));
+ }
+ return add_spaces(out);
+ },
+ "for": function(init, cond, step, block) {
+ var out = [ "for" ];
+ init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space);
+ cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space);
+ step = (step != null ? make(step) : "").replace(/;*\s*$/, "");
+ var args = init + cond + step;
+ if (args == "; ; ") args = ";;";
+ out.push("(" + args + ")", make(block));
+ return add_spaces(out);
+ },
+ "for-in": function(vvar, key, hash, block) {
+ return add_spaces([ "for", "(" +
+ (vvar ? make(vvar).replace(/;+$/, "") : make(key)),
+ "in",
+ make(hash) + ")", make(block) ]);
+ },
+ "while": function(condition, block) {
+ return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]);
+ },
+ "do": function(condition, block) {
+ return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";";
+ },
+ "return": function(expr) {
+ var out = [ "return" ];
+ if (expr != null) out.push(make(expr));
+ return add_spaces(out) + ";";
+ },
+ "binary": function(operator, lvalue, rvalue) {
+ var left = make(lvalue), right = make(rvalue);
+ // XXX: I'm pretty sure other cases will bite here.
+ // we need to be smarter.
+ // adding parens all the time is the safest bet.
+ if (member(lvalue[0], [ "assign", "conditional", "seq" ]) ||
+ lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) {
+ left = "(" + left + ")";
+ }
+ if (member(rvalue[0], [ "assign", "conditional", "seq" ]) ||
+ rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] &&
+ !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) {
+ right = "(" + right + ")";
+ }
+ else if (!beautify && options.inline_script && (operator == "<" || operator == "<<")
+ && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) {
+ right = " " + right;
+ }
+ return add_spaces([ left, operator, right ]);
+ },
+ "unary-prefix": function(operator, expr) {
+ var val = make(expr);
+ if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
+ val = "(" + val + ")";
+ return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val;
+ },
+ "unary-postfix": function(operator, expr) {
+ var val = make(expr);
+ if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
+ val = "(" + val + ")";
+ return val + operator;
+ },
+ "sub": function(expr, subscript) {
+ var hash = make(expr);
+ if (needs_parens(expr))
+ hash = "(" + hash + ")";
+ return hash + "[" + make(subscript) + "]";
+ },
+ "object": function(props) {
+ if (props.length == 0)
+ return "{}";
+ return "{" + newline + with_indent(function(){
+ return MAP(props, function(p){
+ if (p.length == 3) {
+ // getter/setter. The name is in p[0], the arg.list in p[1][2], the
+ // body in p[1][3] and type ("get" / "set") in p[2].
+ return indent(make_function(p[0], p[1][2], p[1][3], p[2]));
+ }
+ var key = p[0], val = make(p[1]);
+ if (options.quote_keys) {
+ key = encode_string(key);
+ } else if ((typeof key == "number" || !beautify && +key + "" == key)
+ && parseFloat(key) >= 0) {
+ key = make_num(+key);
+ } else if (!is_identifier(key)) {
+ key = encode_string(key);
+ }
+ return indent(add_spaces(beautify && options.space_colon
+ ? [ key, ":", val ]
+ : [ key + ":", val ]));
+ }).join("," + newline);
+ }) + newline + indent("}");
+ },
+ "regexp": function(rx, mods) {
+ return "/" + rx + "/" + mods;
+ },
+ "array": function(elements) {
+ if (elements.length == 0) return "[]";
+ return add_spaces([ "[", add_commas(MAP(elements, function(el){
+ if (!beautify && el[0] == "atom" && el[1] == "undefined") return "";
+ return parenthesize(el, "seq");
+ })), "]" ]);
+ },
+ "stat": function(stmt) {
+ return make(stmt).replace(/;*\s*$/, ";");
+ },
+ "seq": function() {
+ return add_commas(MAP(slice(arguments), make));
+ },
+ "label": function(name, block) {
+ return add_spaces([ make_name(name), ":", make(block) ]);
+ },
+ "with": function(expr, block) {
+ return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]);
+ },
+ "atom": function(name) {
+ return make_name(name);
+ }
+ };
+
+ // The squeezer replaces "block"-s that contain only a single
+ // statement with the statement itself; technically, the AST
+ // is correct, but this can create problems when we output an
+ // IF having an ELSE clause where the THEN clause ends in an
+ // IF *without* an ELSE block (then the outer ELSE would refer
+ // to the inner IF). This function checks for this case and
+ // adds the block brackets if needed.
+ function make_then(th) {
+ if (th[0] == "do") {
+ // https://github.com/mishoo/UglifyJS/issues/#issue/57
+ // IE croaks with "syntax error" on code like this:
+ // if (foo) do ... while(cond); else ...
+ // we need block brackets around do/while
+ return make([ "block", [ th ]]);
+ }
+ var b = th;
+ while (true) {
+ var type = b[0];
+ if (type == "if") {
+ if (!b[3])
+ // no else, we must add the block
+ return make([ "block", [ th ]]);
+ b = b[3];
+ }
+ else if (type == "while" || type == "do") b = b[2];
+ else if (type == "for" || type == "for-in") b = b[4];
+ else break;
+ }
+ return make(th);
+ };
+
+ function make_function(name, args, body, keyword) {
+ var out = keyword || "function";
+ if (name) {
+ out += " " + make_name(name);
+ }
+ out += "(" + add_commas(MAP(args, make_name)) + ")";
+ return add_spaces([ out, make_block(body) ]);
+ };
+
+ function make_block_statements(statements, noindent) {
+ for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) {
+ var stat = statements[i];
+ var code = make(stat);
+ if (code != ";") {
+ if (!beautify && i == last) {
+ if ((stat[0] == "while" && empty(stat[2])) ||
+ (member(stat[0], [ "for", "for-in"] ) && empty(stat[4])) ||
+ (stat[0] == "if" && empty(stat[2]) && !stat[3]) ||
+ (stat[0] == "if" && stat[3] && empty(stat[3]))) {
+ code = code.replace(/;*\s*$/, ";");
+ } else {
+ code = code.replace(/;+\s*$/, "");
+ }
+ }
+ a.push(code);
+ }
+ }
+ return noindent ? a : MAP(a, indent);
+ };
+
+ function make_switch_block(body) {
+ var n = body.length;
+ if (n == 0) return "{}";
+ return "{" + newline + MAP(body, function(branch, i){
+ var has_body = branch[1].length > 0, code = with_indent(function(){
+ return indent(branch[0]
+ ? add_spaces([ "case", make(branch[0]) + ":" ])
+ : "default:");
+ }, 0.5) + (has_body ? newline + with_indent(function(){
+ return make_block_statements(branch[1]).join(newline);
+ }) : "");
+ if (!beautify && has_body && i < n - 1)
+ code += ";";
+ return code;
+ }).join(newline) + newline + indent("}");
+ };
+
+ function make_block(statements) {
+ if (!statements) return ";";
+ if (statements.length == 0) return "{}";
+ return "{" + newline + with_indent(function(){
+ return make_block_statements(statements).join(newline);
+ }) + newline + indent("}");
+ };
+
+ function make_1vardef(def) {
+ var name = def[0], val = def[1];
+ if (val != null)
+ name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]);
+ return name;
+ };
+
+ var $stack = [];
+
+ function make(node) {
+ var type = node[0];
+ var gen = generators[type];
+ if (!gen)
+ throw new Error("Can't find generator for \"" + type + "\"");
+ $stack.push(node);
+ var ret = gen.apply(type, node.slice(1));
+ $stack.pop();
+ return ret;
+ };
+
+ return make(ast);
+};
+
+function split_lines(code, max_line_length) {
+ var splits = [ 0 ];
+ jsp.parse(function(){
+ var next_token = jsp.tokenizer(code);
+ var last_split = 0;
+ var prev_token;
+ function current_length(tok) {
+ return tok.pos - last_split;
+ };
+ function split_here(tok) {
+ last_split = tok.pos;
+ splits.push(last_split);
+ };
+ function custom(){
+ var tok = next_token.apply(this, arguments);
+ out: {
+ if (prev_token) {
+ if (prev_token.type == "keyword") break out;
+ }
+ if (current_length(tok) > max_line_length) {
+ switch (tok.type) {
+ case "keyword":
+ case "atom":
+ case "name":
+ case "punc":
+ split_here(tok);
+ break out;
+ }
+ }
+ }
+ prev_token = tok;
+ return tok;
+ };
+ custom.context = function() {
+ return next_token.context.apply(this, arguments);
+ };
+ return custom;
+ }());
+ return splits.map(function(pos, i){
+ return code.substring(pos, splits[i + 1] || code.length);
+ }).join("\n");
+};
+
+/* -----[ Utilities ]----- */
+
+function repeat_string(str, i) {
+ if (i <= 0) return "";
+ if (i == 1) return str;
+ var d = repeat_string(str, i >> 1);
+ d += d;
+ if (i & 1) d += str;
+ return d;
+};
+
+function defaults(args, defs) {
+ var ret = {};
+ if (args === true)
+ args = {};
+ for (var i in defs) if (HOP(defs, i)) {
+ ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
+ }
+ return ret;
+};
+
+function is_identifier(name) {
+ return /^[a-z_$][a-z0-9_$]*$/i.test(name)
+ && name != "this"
+ && !HOP(jsp.KEYWORDS_ATOM, name)
+ && !HOP(jsp.RESERVED_WORDS, name)
+ && !HOP(jsp.KEYWORDS, name);
+};
+
+function HOP(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+// some utilities
+
+var MAP;
+
+(function(){
+ MAP = function(a, f, o) {
+ var ret = [];
+ for (var i = 0; i < a.length; ++i) {
+ var val = f.call(o, a[i], i);
+ if (val instanceof AtTop) ret.unshift(val.v);
+ else ret.push(val);
+ }
+ return ret;
+ };
+ MAP.at_top = function(val) { return new AtTop(val) };
+ function AtTop(val) { this.v = val };
+})();
+
+/* -----[ Exports ]----- */
+
+exports.ast_walker = ast_walker;
+exports.ast_mangle = ast_mangle;
+exports.ast_squeeze = ast_squeeze;
+exports.gen_code = gen_code;
+exports.ast_add_scope = ast_add_scope;
+exports.set_logger = function(logger) { warn = logger };
+exports.make_string = make_string;
+exports.split_lines = split_lines;
+exports.MAP = MAP;
+
+// keep this last!
+exports.ast_squeeze_more = require("./squeeze-more").ast_squeeze_more;
--- /dev/null
+var jsp = require("./parse-js"),
+ pro = require("./process"),
+ slice = jsp.slice,
+ member = jsp.member,
+ PRECEDENCE = jsp.PRECEDENCE,
+ OPERATORS = jsp.OPERATORS;
+
+function ast_squeeze_more(ast) {
+ var w = pro.ast_walker(), walk = w.walk;
+ return w.with_walkers({
+ "call": function(expr, args) {
+ if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+ // foo.toString() ==> foo+""
+ return [ "binary", "+", expr[1], [ "string", "" ]];
+ }
+ }
+ }, function() {
+ return walk(ast);
+ });
+};
+
+exports.ast_squeeze_more = ast_squeeze_more;
--- /dev/null
+{
+ "name" : "uglify-js",
+
+ "author" : {
+ "name" : "Mihai Bazon",
+ "email" : "mihai.bazon@gmail.com",
+ "url" : "http://mihai.bazon.net/blog"
+ },
+
+ "version" : "1.0.6",
+
+ "main" : "./uglify-js.js",
+
+ "bin" : {
+ "uglifyjs" : "./bin/uglifyjs"
+ },
+
+ "repository": {
+ "type": "git",
+ "url": "git@github.com:mishoo/UglifyJS.git"
+ }
+}
--- /dev/null
+#! /usr/bin/env node
+
+global.sys = require("sys");
+var fs = require("fs");
+
+var jsp = require("../lib/parse-js");
+var pro = require("../lib/process");
+
+var filename = process.argv[2];
+fs.readFile(filename, "utf8", function(err, text){
+ try {
+ var ast = time_it("parse", function(){ return jsp.parse(text); });
+ ast = time_it("mangle", function(){ return pro.ast_mangle(ast); });
+ ast = time_it("squeeze", function(){ return pro.ast_squeeze(ast); });
+ var gen = time_it("generate", function(){ return pro.gen_code(ast, false); });
+ sys.puts(gen);
+ } catch(ex) {
+ sys.debug(ex.stack);
+ sys.debug(sys.inspect(ex));
+ sys.debug(JSON.stringify(ex));
+ }
+});
+
+function time_it(name, cont) {
+ var t1 = new Date().getTime();
+ try { return cont(); }
+ finally { sys.debug("// " + name + ": " + ((new Date().getTime() - t1) / 1000).toFixed(3) + " sec."); }
+};
--- /dev/null
+#! /usr/bin/env node
+
+var parseJS = require("../lib/parse-js");
+var sys = require("sys");
+
+// write debug in a very straightforward manner
+var debug = function(){
+ sys.log(Array.prototype.slice.call(arguments).join(', '));
+};
+
+ParserTestSuite(function(i, input, desc){
+ try {
+ parseJS.parse(input);
+ debug("ok " + i + ": " + desc);
+ } catch(e){
+ debug("FAIL " + i + " " + desc + " (" + e + ")");
+ }
+});
+
+function ParserTestSuite(callback){
+ var inps = [
+ ["var abc;", "Regular variable statement w/o assignment"],
+ ["var abc = 5;", "Regular variable statement with assignment"],
+ ["/* */;", "Multiline comment"],
+ ['/** **/;', 'Double star multiline comment'],
+ ["var f = function(){;};", "Function expression in var assignment"],
+ ['hi; // moo\n;', 'single line comment'],
+ ['var varwithfunction;', 'Dont match keywords as substrings'], // difference between `var withsomevar` and `"str"` (local search and lits)
+ ['a + b;', 'addition'],
+ ["'a';", 'single string literal'],
+ ["'a\\n';", 'single string literal with escaped return'],
+ ['"a";', 'double string literal'],
+ ['"a\\n";', 'double string literal with escaped return'],
+ ['"var";', 'string is a keyword'],
+ ['"variable";', 'string starts with a keyword'],
+ ['"somevariable";', 'string contains a keyword'],
+ ['"somevar";', 'string ends with a keyword'],
+ ['500;', 'int literal'],
+ ['500.;', 'float literal w/o decimals'],
+ ['500.432;', 'float literal with decimals'],
+ ['.432432;', 'float literal w/o int'],
+ ['(a,b,c);', 'parens and comma'],
+ ['[1,2,abc];', 'array literal'],
+ ['var o = {a:1};', 'object literal unquoted key'],
+ ['var o = {"b":2};', 'object literal quoted key'], // opening curly may not be at the start of a statement...
+ ['var o = {c:c};', 'object literal keyname is identifier'],
+ ['var o = {a:1,"b":2,c:c};', 'object literal combinations'],
+ ['var x;\nvar y;', 'two lines'],
+ ['var x;\nfunction n(){; }', 'function def'],
+ ['var x;\nfunction n(abc){; }', 'function def with arg'],
+ ['var x;\nfunction n(abc, def){ ;}', 'function def with args'],
+ ['function n(){ "hello"; }', 'function def with body'],
+ ['/a/;', 'regex literal'],
+ ['/a/b;', 'regex literal with flag'],
+ ['/a/ / /b/;', 'regex div regex'],
+ ['a/b/c;', 'triple division looks like regex'],
+ ['+function(){/regex/;};', 'regex at start of function body'],
+ // http://code.google.com/p/es-lab/source/browse/trunk/tests/parser/parsertests.js?r=86
+ // http://code.google.com/p/es-lab/source/browse/trunk/tests/parser/parsertests.js?r=430
+
+ // first tests for the lexer, should also parse as program (when you append a semi)
+
+ // comments
+ ['//foo!@#^&$1234\nbar;', 'single line comment'],
+ ['/* abcd!@#@$* { } && null*/;', 'single line multi line comment'],
+ ['/*foo\nbar*/;','multi line comment'],
+ ['/*x*x*/;','multi line comment with *'],
+ ['/**/;','empty comment'],
+ // identifiers
+ ["x;",'1 identifier'],
+ ["_x;",'2 identifier'],
+ ["xyz;",'3 identifier'],
+ ["$x;",'4 identifier'],
+ ["x$;",'5 identifier'],
+ ["_;",'6 identifier'],
+ ["x5;",'7 identifier'],
+ ["x_y;",'8 identifier'],
+ ["x+5;",'9 identifier'],
+ ["xyz123;",'10 identifier'],
+ ["x1y1z1;",'11 identifier'],
+ ["foo\\u00D8bar;",'12 identifier unicode escape'],
+ //["foo�bar;",'13 identifier unicode embedded (might fail)'],
+ // numbers
+ ["5;", '1 number'],
+ ["5.5;", '2 number'],
+ ["0;", '3 number'],
+ ["0.0;", '4 number'],
+ ["0.001;", '5 number'],
+ ["1.e2;", '6 number'],
+ ["1.e-2;", '7 number'],
+ ["1.E2;", '8 number'],
+ ["1.E-2;", '9 number'],
+ [".5;", '10 number'],
+ [".5e3;", '11 number'],
+ [".5e-3;", '12 number'],
+ ["0.5e3;", '13 number'],
+ ["55;", '14 number'],
+ ["123;", '15 number'],
+ ["55.55;", '16 number'],
+ ["55.55e10;", '17 number'],
+ ["123.456;", '18 number'],
+ ["1+e;", '20 number'],
+ ["0x01;", '22 number'],
+ ["0XCAFE;", '23 number'],
+ ["0x12345678;", '24 number'],
+ ["0x1234ABCD;", '25 number'],
+ ["0x0001;", '26 number'],
+ // strings
+ ["\"foo\";", '1 string'],
+ ["\'foo\';", '2 string'],
+ ["\"x\";", '3 string'],
+ ["\'\';", '4 string'],
+ ["\"foo\\tbar\";", '5 string'],
+ ["\"!@#$%^&*()_+{}[]\";", '6 string'],
+ ["\"/*test*/\";", '7 string'],
+ ["\"//test\";", '8 string'],
+ ["\"\\\\\";", '9 string'],
+ ["\"\\u0001\";", '10 string'],
+ ["\"\\uFEFF\";", '11 string'],
+ ["\"\\u10002\";", '12 string'],
+ ["\"\\x55\";", '13 string'],
+ ["\"\\x55a\";", '14 string'],
+ ["\"a\\\\nb\";", '15 string'],
+ ['";"', '16 string: semi in a string'],
+ ['"a\\\nb";', '17 string: line terminator escape'],
+ // literals
+ ["null;", "null"],
+ ["true;", "true"],
+ ["false;", "false"],
+ // regex
+ ["/a/;", "1 regex"],
+ ["/abc/;", "2 regex"],
+ ["/abc[a-z]*def/g;", "3 regex"],
+ ["/\\b/;", "4 regex"],
+ ["/[a-zA-Z]/;", "5 regex"],
+
+ // program tests (for as far as they havent been covered above)
+
+ // regexp
+ ["/foo(.*)/g;", "another regexp"],
+ // arrays
+ ["[];", "1 array"],
+ ["[ ];", "2 array"],
+ ["[1];", "3 array"],
+ ["[1,2];", "4 array"],
+ ["[1,2,,];", "5 array"],
+ ["[1,2,3];", "6 array"],
+ ["[1,2,3,,,];", "7 array"],
+ // objects
+ ["{};", "1 object"],
+ ["({x:5});", "2 object"],
+ ["({x:5,y:6});", "3 object"],
+ ["({x:5,});", "4 object"],
+ ["({if:5});", "5 object"],
+ ["({ get x() {42;} });", "6 object"],
+ ["({ set y(a) {1;} });", "7 object"],
+ // member expression
+ ["o.m;", "1 member expression"],
+ ["o['m'];", "2 member expression"],
+ ["o['n']['m'];", "3 member expression"],
+ ["o.n.m;", "4 member expression"],
+ ["o.if;", "5 member expression"],
+ // call and invoke expressions
+ ["f();", "1 call/invoke expression"],
+ ["f(x);", "2 call/invoke expression"],
+ ["f(x,y);", "3 call/invoke expression"],
+ ["o.m();", "4 call/invoke expression"],
+ ["o['m'];", "5 call/invoke expression"],
+ ["o.m(x);", "6 call/invoke expression"],
+ ["o['m'](x);", "7 call/invoke expression"],
+ ["o.m(x,y);", "8 call/invoke expression"],
+ ["o['m'](x,y);", "9 call/invoke expression"],
+ ["f(x)(y);", "10 call/invoke expression"],
+ ["f().x;", "11 call/invoke expression"],
+
+ // eval
+ ["eval('x');", "1 eval"],
+ ["(eval)('x');", "2 eval"],
+ ["(1,eval)('x');", "3 eval"],
+ ["eval(x,y);", "4 eval"],
+ // new expression
+ ["new f();", "1 new expression"],
+ ["new o;", "2 new expression"],
+ ["new o.m;", "3 new expression"],
+ ["new o.m(x);", "4 new expression"],
+ ["new o.m(x,y);", "5 new expression"],
+ // prefix/postfix
+ ["++x;", "1 pre/postfix"],
+ ["x++;", "2 pre/postfix"],
+ ["--x;", "3 pre/postfix"],
+ ["x--;", "4 pre/postfix"],
+ ["x ++;", "5 pre/postfix"],
+ ["x /* comment */ ++;", "6 pre/postfix"],
+ ["++ /* comment */ x;", "7 pre/postfix"],
+ // unary operators
+ ["delete x;", "1 unary operator"],
+ ["void x;", "2 unary operator"],
+ ["+ x;", "3 unary operator"],
+ ["-x;", "4 unary operator"],
+ ["~x;", "5 unary operator"],
+ ["!x;", "6 unary operator"],
+ // meh
+ ["new Date++;", "new date ++"],
+ ["+x++;", " + x ++"],
+ // expression expressions
+ ["1 * 2;", "1 expression expressions"],
+ ["1 / 2;", "2 expression expressions"],
+ ["1 % 2;", "3 expression expressions"],
+ ["1 + 2;", "4 expression expressions"],
+ ["1 - 2;", "5 expression expressions"],
+ ["1 << 2;", "6 expression expressions"],
+ ["1 >>> 2;", "7 expression expressions"],
+ ["1 >> 2;", "8 expression expressions"],
+ ["1 * 2 + 3;", "9 expression expressions"],
+ ["(1+2)*3;", "10 expression expressions"],
+ ["1*(2+3);", "11 expression expressions"],
+ ["x<y;", "12 expression expressions"],
+ ["x>y;", "13 expression expressions"],
+ ["x<=y;", "14 expression expressions"],
+ ["x>=y;", "15 expression expressions"],
+ ["x instanceof y;", "16 expression expressions"],
+ ["x in y;", "17 expression expressions"],
+ ["x&y;", "18 expression expressions"],
+ ["x^y;", "19 expression expressions"],
+ ["x|y;", "20 expression expressions"],
+ ["x+y<z;", "21 expression expressions"],
+ ["x<y+z;", "22 expression expressions"],
+ ["x+y+z;", "23 expression expressions"],
+ ["x+y<z;", "24 expression expressions"],
+ ["x<y+z;", "25 expression expressions"],
+ ["x&y|z;", "26 expression expressions"],
+ ["x&&y;", "27 expression expressions"],
+ ["x||y;", "28 expression expressions"],
+ ["x&&y||z;", "29 expression expressions"],
+ ["x||y&&z;", "30 expression expressions"],
+ ["x<y?z:w;", "31 expression expressions"],
+ // assignment
+ ["x >>>= y;", "1 assignment"],
+ ["x <<= y;", "2 assignment"],
+ ["x = y;", "3 assignment"],
+ ["x += y;", "4 assignment"],
+ ["x /= y;", "5 assignment"],
+ // comma
+ ["x, y;", "comma"],
+ // block
+ ["{};", "1 block"],
+ ["{x;};", "2 block"],
+ ["{x;y;};", "3 block"],
+ // vars
+ ["var x;", "1 var"],
+ ["var x,y;", "2 var"],
+ ["var x=1,y=2;", "3 var"],
+ ["var x,y=2;", "4 var"],
+ // empty
+ [";", "1 empty"],
+ ["\n;", "2 empty"],
+ // expression statement
+ ["x;", "1 expression statement"],
+ ["5;", "2 expression statement"],
+ ["1+2;", "3 expression statement"],
+ // if
+ ["if (c) x; else y;", "1 if statement"],
+ ["if (c) x;", "2 if statement"],
+ ["if (c) {} else {};", "3 if statement"],
+ ["if (c1) if (c2) s1; else s2;", "4 if statement"],
+ // while
+ ["do s; while (e);", "1 while statement"],
+ ["do { s; } while (e);", "2 while statement"],
+ ["while (e) s;", "3 while statement"],
+ ["while (e) { s; };", "4 while statement"],
+ // for
+ ["for (;;) ;", "1 for statement"],
+ ["for (;c;x++) x;", "2 for statement"],
+ ["for (i;i<len;++i){};", "3 for statement"],
+ ["for (var i=0;i<len;++i) {};", "4 for statement"],
+ ["for (var i=0,j=0;;){};", "5 for statement"],
+ //["for (x in b; c; u) {};", "6 for statement"],
+ ["for ((x in b); c; u) {};", "7 for statement"],
+ ["for (x in a);", "8 for statement"],
+ ["for (var x in a){};", "9 for statement"],
+ ["for (var x=5 in a) {};", "10 for statement"],
+ ["for (var x = a in b in c) {};", "11 for statement"],
+ ["for (var x=function(){a+b;}; a<b; ++i) some;", "11 for statement, testing for parsingForHeader reset with the function"],
+ ["for (var x=function(){for (x=0; x<15; ++x) alert(foo); }; a<b; ++i) some;", "11 for statement, testing for parsingForHeader reset with the function"],
+ // flow statements
+ ["while(1){ continue; }", "1 flow statement"],
+ ["label: while(1){ continue label; }", "2 flow statement"],
+ ["while(1){ break; }", "3 flow statement"],
+ ["somewhere: while(1){ break somewhere; }", "4 flow statement"],
+ ["while(1){ continue /* comment */ ; }", "5 flow statement"],
+ ["while(1){ continue \n; }", "6 flow statement"],
+ ["(function(){ return; })()", "7 flow statement"],
+ ["(function(){ return 0; })()", "8 flow statement"],
+ ["(function(){ return 0 + \n 1; })()", "9 flow statement"],
+ // with
+ ["with (e) s;", "with statement"],
+ // switch
+ ["switch (e) { case x: s; };", "1 switch statement"],
+ ["switch (e) { case x: s1;s2; default: s3; case y: s4; };", "2 switch statement"],
+ ["switch (e) { default: s1; case x: s2; case y: s3; };", "3 switch statement"],
+ ["switch (e) { default: s; };", "4 switch statement"],
+ ["switch (e) { case x: s1; case y: s2; };", "5 switch statement"],
+ // labels
+ ["foo : x;", " flow statement"],
+ // throw
+ ["throw x;", "1 throw statement"],
+ ["throw x\n;", "2 throw statement"],
+ // try catch finally
+ ["try { s1; } catch (e) { s2; };", "1 trycatchfinally statement"],
+ ["try { s1; } finally { s2; };", "2 trycatchfinally statement"],
+ ["try { s1; } catch (e) { s2; } finally { s3; };", "3 trycatchfinally statement"],
+ // debugger
+ ["debugger;", "debuger statement"],
+ // function decl
+ ["function f(x) { e; return x; };", "1 function declaration"],
+ ["function f() { x; y; };", "2 function declaration"],
+ ["function f(x,y) { var z; return x; };", "3 function declaration"],
+ // function exp
+ ["(function f(x) { return x; });", "1 function expression"],
+ ["(function empty() {;});", "2 function expression"],
+ ["(function empty() {;});", "3 function expression"],
+ ["(function (x) {; });", "4 function expression"],
+ // program
+ ["var x; function f(){;}; null;", "1 program"],
+ [";;", "2 program"],
+ ["{ x; y; z; }", "3 program"],
+ ["function f(){ function g(){;}};", "4 program"],
+ ["x;\n/*foo*/\n ;", "5 program"],
+
+ // asi
+ ["foo: while(1){ continue \n foo; }", "1 asi"],
+ ["foo: while(1){ break \n foo; }", "2 asi"],
+ ["(function(){ return\nfoo; })()", "3 asi"],
+ ["var x; { 1 \n 2 } 3", "4 asi"],
+ ["ab /* hi */\ncd", "5 asi"],
+ ["ab/*\n*/cd", "6 asi (multi line multilinecomment counts as eol)"],
+ ["foo: while(1){ continue /* wtf \n busta */ foo; }", "7 asi illegal with multi line comment"],
+ ["function f() { s }", "8 asi"],
+ ["function f() { return }", "9 asi"],
+
+ // use strict
+ // XXX: some of these should actually fail?
+ // no support for "use strict" yet...
+ ['"use strict"; \'bla\'\n; foo;', "1 directive"],
+ ['(function() { "use strict"; \'bla\';\n foo; });', "2 directive"],
+ ['"use\\n strict";', "3 directive"],
+ ['foo; "use strict";', "4 directive"],
+
+ // tests from http://es5conform.codeplex.com/
+
+ ['"use strict"; var o = { eval: 42};', "8.7.2-3-1-s: the use of eval as property name is allowed"],
+ ['({foo:0,foo:1});', 'Duplicate property name allowed in not strict mode'],
+ ['function foo(a,a){}', 'Duplicate parameter name allowed in not strict mode'],
+ ['(function foo(eval){})', 'Eval allowed as parameter name in non strict mode'],
+ ['(function foo(arguments){})', 'Arguments allowed as parameter name in non strict mode'],
+
+ // empty programs
+
+ ['', '1 Empty program'],
+ ['// test', '2 Empty program'],
+ ['//test\n', '3 Empty program'],
+ ['\n// test', '4 Empty program'],
+ ['\n// test\n', '5 Empty program'],
+ ['/* */', '6 Empty program'],
+ ['/*\ns,fd\n*/', '7 Empty program'],
+ ['/*\ns,fd\n*/\n', '8 Empty program'],
+ [' ', '9 Empty program'],
+ [' /*\nsmeh*/ \n ', '10 Empty program'],
+
+ // trailing whitespace
+
+ ['a ', '1 Trailing whitespace'],
+ ['a /* something */', '2 Trailing whitespace'],
+ ['a\n // hah', '3 Trailing whitespace'],
+ ['/abc/de//f', '4 Trailing whitespace'],
+ ['/abc/de/*f*/\n ', '5 Trailing whitespace'],
+
+ // things the parser tripped over at one point or the other (prevents regression bugs)
+ ['for (x;function(){ a\nb };z) x;', 'for header with function body forcing ASI'],
+ ['c=function(){return;return};', 'resetting noAsi after literal'],
+ ['d\nd()', 'asi exception causing token overflow'],
+ ['for(;;){x=function(){}}', 'function expression in a for header'],
+ ['for(var k;;){}', 'parser failing due to ASI accepting the incorrect "for" rule'],
+ ['({get foo(){ }})', 'getter with empty function body'],
+ ['\nreturnr', 'eol causes return statement to ignore local search requirement'],
+ [' / /', '1 whitespace before regex causes regex to fail?'],
+ ['/ // / /', '2 whitespace before regex causes regex to fail?'],
+ ['/ / / / /', '3 whitespace before regex causes regex to fail?'],
+
+ ['\n\t// Used for trimming whitespace\n\ttrimLeft = /^\\s+/;\n\ttrimRight = /\\s+$/;\t\n','turned out this didnt crash (the test below did), but whatever.'],
+ ['/[\\/]/;', 'escaped forward slash inside class group (would choke on fwd slash)'],
+ ['/[/]/;', 'also broke but is valid in es5 (not es3)'],
+ ['({get:5});','get property name thats not a getter'],
+ ['({set:5});','set property name thats not a setter'],
+ ['l !== "px" && (d.style(h, c, (k || 1) + l), j = (k || 1) / f.cur() * j, d.style(h, c, j + l)), i[1] && (k = (i[1] === "-=" ? -1 : 1) * k + j), f.custom(j, k, l)', 'this choked regex/div at some point'],
+ ['(/\'/g, \'\\\\\\\'\') + "\'";', 'the sequence of escaped characters confused the tokenizer']
+ ];
+
+ for (var i=0; i<inps.length; ++i) {
+ callback(i, inps[i][0], inps[i][1]);
+ };
+};
--- /dev/null
+[],Array(1),[1,2,3]
--- /dev/null
+(function(){var a=function(){};return new a(1,2,3,4)})()
--- /dev/null
+(function(){function a(){}return new a(1,2,3,4)})()
--- /dev/null
+(function(){function a(){}(function(){return new a(1,2,3)})()})()
--- /dev/null
+a=1,b=a,c=1,d=b,e=d,longname=2;if(longname+1){x=3;if(x)var z=7}z=1,y=1,x=1,g+=1,h=g,++i,j=i,i++,j=i+17
\ No newline at end of file
--- /dev/null
+var a=a+"a"+"b"+1+c,b=a+"c"+"ds"+123+c,c=a+"c"+123+d+"ds"+c
\ No newline at end of file
--- /dev/null
+var a=13,b=1/3
\ No newline at end of file
--- /dev/null
+function mak(){for(;;);}function foo(){while(bar());}function bar(){return--x}var x=5
--- /dev/null
+a=func(),b=z;for(a++;i<10;i++)alert(i);var z=1;g=2;for(;i<10;i++)alert(i);var a=2;for(var i=1;i<10;i++)alert(i)
\ No newline at end of file
--- /dev/null
+var a=1;a==1?a=2:a=17
\ No newline at end of file
--- /dev/null
+function a(a){return a==1?2:17}
\ No newline at end of file
--- /dev/null
+function y(a){return typeof a=="object"?a:null}function x(a){return typeof a=="object"?a:a===42?0:a*2}
--- /dev/null
+function f(){var a;return(a="a")?a:a}f()
\ No newline at end of file
--- /dev/null
+new(A,B),new(A||B),new(X?A:B)
\ No newline at end of file
--- /dev/null
+var a=/^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#])(?::(\d))?)?(..?$|(?:[^?#\/]\/))([^?#]*)(?:\?([^#]))?(?:#(.))?/
\ No newline at end of file
--- /dev/null
+var a={"\b":"\\b","\t":"\\t","\n":"\\n","\f":"\\f","\r":"\\r",'"':'\\"',"\\":"\\\\"}
--- /dev/null
+var a=3250441966
\ No newline at end of file
--- /dev/null
+var a=function(b){b(),a()}
\ No newline at end of file
--- /dev/null
+a:1
\ No newline at end of file
--- /dev/null
+var a=0;switch(a){case 0:a++}
\ No newline at end of file
--- /dev/null
+label1:{label2:break label2;console.log(1)}
\ No newline at end of file
--- /dev/null
+(a?b:c)?d:e
\ No newline at end of file
--- /dev/null
+o={".5":.5},o={.5:.5},o={.5:.5}
\ No newline at end of file
--- /dev/null
+result=function(){return 1}()
\ No newline at end of file
--- /dev/null
+var a=8,b=4,c=4
\ No newline at end of file
--- /dev/null
+var a={};a["this"]=1,a.that=2
\ No newline at end of file
--- /dev/null
+var a=2e3,b=.002,c=2e-5
\ No newline at end of file
--- /dev/null
+var s,i;s="",i=0
\ No newline at end of file
--- /dev/null
+function bar(a){try{foo()}catch(b){alert("Exception caught (foo not defined)")}alert(a)}bar(10)
--- /dev/null
+foo+"",a.toString(16),b.toString.call(c)
--- /dev/null
+function f(){function b(){}a||b()}
--- /dev/null
+var a={a:1,b:2}
\ No newline at end of file
--- /dev/null
+(function(){var a=function b(a,b,c){return b}})()
--- /dev/null
+typeof a=="string",b+""!=c+"",d<e==f<g
\ No newline at end of file
--- /dev/null
+var a=1,b=2
\ No newline at end of file
--- /dev/null
+new Array();
+new Array(1);
+new Array(1, 2, 3);
--- /dev/null
+(function(){
+ var Array = function(){};
+ return new Array(1, 2, 3, 4);
+})();
--- /dev/null
+(function(){
+ return new Array(1, 2, 3, 4);
+ function Array() {};
+})();
--- /dev/null
+(function(){
+ (function(){
+ return new Array(1, 2, 3);
+ })();
+ function Array(){};
+})();
--- /dev/null
+a=1;
+b=a;
+c=1;
+d=b;
+e=d;
+longname=2;
+if (longname+1) {
+ x=3;
+ if (x) var z = 7;
+}
+z=1,y=1,x=1
+
+g+=1;
+h=g;
+
+++i;
+j=i;
+
+i++;
+j=i+17;
\ No newline at end of file
--- /dev/null
+var a = a + "a" + "b" + 1 + c;
+var b = a + "c" + "ds" + 123 + c;
+var c = a + "c" + 123 + d + "ds" + c;
\ No newline at end of file
--- /dev/null
+// test that the calculation is fold to 13\r
+var a = 1 + 2 * 6;\r
+\r
+// test that it isn't replaced with 0.3333 because that is more characters\r
+var b = 1/3;
\ No newline at end of file
--- /dev/null
+var x = 5;
+function bar() { return --x; }
+function foo() { while (bar()); }
+function mak() { for(;;); }
--- /dev/null
+a=func();
+b=z;
+for (a++; i < 10; i++) { alert(i); }
+
+var z=1;
+g=2;
+for (; i < 10; i++) { alert(i); }
+
+var a = 2;
+for (var i = 1; i < 10; i++) { alert(i); }
--- /dev/null
+var a = 1;\r
+if (a == 1) {\r
+ a = 2;\r
+} else {\r
+ a = 17;\r
+}\r
--- /dev/null
+function a(b) {\r
+ if (b == 1) {\r
+ return 2;\r
+ } else {\r
+ return 17;\r
+ }\r
+\r
+ return 3;\r
+}
\ No newline at end of file
--- /dev/null
+function x(a) {
+ if (typeof a === 'object')
+ return a;
+
+ if (a === 42)
+ return 0;
+
+ return a * 2;
+}
+
+function y(a) {
+ if (typeof a === 'object')
+ return a;
+
+ return null;
+};
--- /dev/null
+function f() { var a; if (a = 'a') { return a; } else { return a; } }; f();
\ No newline at end of file
--- /dev/null
+new (A, B)
+new (A || B)
+new (X ? A : B)
\ No newline at end of file
--- /dev/null
+var a = /^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#])(?::(\d))?)?(..?$|(?:[^?#\/]\/))([^?#]*)(?:\?([^#]))?(?:#(.))?/;
\ No newline at end of file
--- /dev/null
+var a = {'\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '\\': '\\\\'};
\ No newline at end of file
--- /dev/null
+var a = 0xC1BDCEEE;
\ No newline at end of file
--- /dev/null
+var a = function(b) {
+ b();
+ a()
+}
--- /dev/null
+{a: 1}
\ No newline at end of file
--- /dev/null
+var a = 0;
+switch(a) {
+ case 0:
+ a++;
+ break;
+}
\ No newline at end of file
--- /dev/null
+label1 : {
+ label2 : {
+ break label2;
+ console.log(2);
+ }
+ console.log(1);
+}
\ No newline at end of file
--- /dev/null
+(a ? b : c) ? d : e
\ No newline at end of file
--- /dev/null
+o = {'.5':.5}
+o = {'0.5':.5}
+o = {0.5:.5}
\ No newline at end of file
--- /dev/null
+result=(function(){ return 1;})()
\ No newline at end of file
--- /dev/null
+var a = 1 << 3;
+var b = 8 >> 1;
+var c = 8 >>> 1;
\ No newline at end of file
--- /dev/null
+var a = {};
+a["this"] = 1;
+a["that"] = 2;
\ No newline at end of file
--- /dev/null
+var a = 2e3;
+var b = 2e-3;
+var c = 2e-5;
\ No newline at end of file
--- /dev/null
+var s, i; s = ''; i = 0;
\ No newline at end of file
--- /dev/null
+function bar(a) {
+ try {
+ foo();
+ } catch(e) {
+ alert("Exception caught (foo not defined)");
+ }
+ alert(a); // 10 in FF, "[object Error]" in IE
+}
+bar(10);
--- /dev/null
+x = (y, z)
--- /dev/null
+foo.toString();
+a.toString(16);
+b.toString.call(c);
--- /dev/null
+function f() {
+ if (a) return;
+ g();
+ function g(){}
+};
--- /dev/null
+var a = {
+ a: 1,
+ b: 2, // <-- trailing comma
+};
--- /dev/null
+(function() {
+ var x = function fun(a, fun, b) {
+ return fun;
+ };
+}());
--- /dev/null
+typeof a === 'string'
+b + "" !== c + ""
+d < e === f < g
--- /dev/null
+// var declarations after each other should be combined\r
+var a = 1;\r
+var b = 2;
\ No newline at end of file
--- /dev/null
+with({}) {
+};
--- /dev/null
+var fs = require('fs'),
+ uglify = require('uglify-js'),
+ jsp = uglify.parser,
+ nodeunit = require('nodeunit'),
+ path = require('path'),
+ pro = uglify.uglify;
+
+var Script = process.binding('evals').Script;
+
+var scriptsPath = __dirname;
+
+function compress(code) {
+ var ast = jsp.parse(code);
+ ast = pro.ast_mangle(ast);
+ ast = pro.ast_squeeze(ast, {no_warnings: true, extra: true});
+ ast = pro.ast_squeeze_more(ast);
+ return pro.gen_code(ast);
+};
+
+var testDir = path.join(scriptsPath, "compress", "test");
+var expectedDir = path.join(scriptsPath, "compress", "expected");
+
+function getTester(script) {
+ return function(test) {
+ var testPath = path.join(testDir, script);
+ var expectedPath = path.join(expectedDir, script);
+ var content = fs.readFileSync(testPath, 'utf-8');
+ var outputCompress = compress(content);
+
+ // Check if the noncompressdata is larger or same size as the compressed data
+ test.ok(content.length >= outputCompress.length);
+
+ // Check that a recompress gives the same result
+ var outputReCompress = compress(content);
+ test.equal(outputCompress, outputReCompress);
+
+ // Check if the compressed output is what is expected
+ var expected = fs.readFileSync(expectedPath, 'utf-8');
+ test.equal(outputCompress, expected.replace(/(\r?\n)+$/, ""));
+
+ test.done();
+ };
+};
+
+var tests = {};
+
+var scripts = fs.readdirSync(testDir);
+for (var i in scripts) {
+ var script = scripts[i];
+ if (/\.js$/.test(script)) {
+ tests[script] = getTester(script);
+ }
+}
+
+module.exports = nodeunit.testCase(tests);
--- /dev/null
+// sample on how to use the parser and walker API to instrument some code
+
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+function instrument(code) {
+ var ast = jsp.parse(code, false, true); // true for the third arg specifies that we want
+ // to have start/end tokens embedded in the
+ // statements
+ var w = pro.ast_walker();
+
+ // we're gonna need this to push elements that we're currently looking at, to avoid
+ // endless recursion.
+ var analyzing = [];
+ function do_stat() {
+ var ret;
+ if (this[0].start && analyzing.indexOf(this) < 0) {
+ // without the `analyzing' hack, w.walk(this) would re-enter here leading
+ // to infinite recursion
+ analyzing.push(this);
+ ret = [ "splice", // XXX: "block" is safer
+ [ [ "stat",
+ [ "call", [ "name", "trace" ],
+ [ [ "string", this[0].toString() ],
+ [ "num", this[0].start.line ],
+ [ "num", this[0].start.col ],
+ [ "num", this[0].end.line ],
+ [ "num", this[0].end.col ]]]],
+ w.walk(this) ]];
+ analyzing.pop(this);
+ }
+ return ret;
+ };
+ var new_ast = w.with_walkers({
+ "stat" : do_stat,
+ "label" : do_stat,
+ "break" : do_stat,
+ "continue" : do_stat,
+ "debugger" : do_stat,
+ "var" : do_stat,
+ "const" : do_stat,
+ "return" : do_stat,
+ "throw" : do_stat,
+ "try" : do_stat,
+ "defun" : do_stat,
+ "if" : do_stat,
+ "while" : do_stat,
+ "do" : do_stat,
+ "for" : do_stat,
+ "for-in" : do_stat,
+ "switch" : do_stat,
+ "with" : do_stat
+ }, function(){
+ return w.walk(ast);
+ });
+ return pro.gen_code(new_ast, { beautify: true });
+}
+
+
+
+
+////// test code follows.
+
+var code = instrument(test.toString());
+console.log(code);
+
+function test() {
+ // simple stats
+ a = 5;
+ c += a + b;
+ "foo";
+
+ // var
+ var foo = 5;
+ const bar = 6, baz = 7;
+
+ // switch block. note we can't track case lines the same way.
+ switch ("foo") {
+ case "foo":
+ return 1;
+ case "bar":
+ return 2;
+ }
+
+ // for/for in
+ for (var i = 0; i < 5; ++i) {
+ console.log("Hello " + i);
+ }
+ for (var i in [ 1, 2, 3]) {
+ console.log(i);
+ }
+
+ // note however that the following is broken. I guess we
+ // should add the block brackets in this case...
+ for (var i = 0; i < 5; ++i)
+ console.log("foo");
+}
--- /dev/null
+// sample on how to use the parser and walker API to instrument some code
+
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+function instrument(code) {
+ var ast = jsp.parse(code, false, true); // true for the third arg specifies that we want
+ // to have start/end tokens embedded in the
+ // statements
+ var w = pro.ast_walker();
+
+ function trace (line, comment) {
+ var code = pro.gen_code(line, { beautify: true });
+ var data = line[0]
+
+ var args = []
+ if (!comment) comment = ""
+ if (typeof data === "object") {
+ code = code.split(/\n/).shift()
+ args = [ [ "string", data.toString() ],
+ [ "string", code ],
+ [ "num", data.start.line ],
+ [ "num", data.start.col ],
+ [ "num", data.end.line ],
+ [ "num", data.end.col ]]
+ } else {
+ args = [ [ "string", data ],
+ [ "string", code ]]
+
+ }
+ return [ "call", [ "name", "trace" ], args ];
+ }
+
+ // we're gonna need this to push elements that we're currently looking at, to avoid
+ // endless recursion.
+ var analyzing = [];
+ function do_stat() {
+ var ret;
+ if (this[0].start && analyzing.indexOf(this) < 0) {
+ // without the `analyzing' hack, w.walk(this) would re-enter here leading
+ // to infinite recursion
+ analyzing.push(this);
+ ret = [ "splice",
+ [ [ "stat", trace(this) ],
+ w.walk(this) ]];
+ analyzing.pop(this);
+ }
+ return ret;
+ }
+
+ function do_cond(c, t, f) {
+ return [ this[0], w.walk(c),
+ ["seq", trace(t), w.walk(t) ],
+ ["seq", trace(f), w.walk(f) ]];
+ }
+
+ function do_binary(c, l, r) {
+ if (c !== "&&" && c !== "||") {
+ return [this[0], c, w.walk(l), w.walk(r)];
+ }
+ return [ this[0], c,
+ ["seq", trace(l), w.walk(l) ],
+ ["seq", trace(r), w.walk(r) ]];
+ }
+
+ var new_ast = w.with_walkers({
+ "stat" : do_stat,
+ "label" : do_stat,
+ "break" : do_stat,
+ "continue" : do_stat,
+ "debugger" : do_stat,
+ "var" : do_stat,
+ "const" : do_stat,
+ "return" : do_stat,
+ "throw" : do_stat,
+ "try" : do_stat,
+ "defun" : do_stat,
+ "if" : do_stat,
+ "while" : do_stat,
+ "do" : do_stat,
+ "for" : do_stat,
+ "for-in" : do_stat,
+ "switch" : do_stat,
+ "with" : do_stat,
+ "conditional" : do_cond,
+ "binary" : do_binary
+ }, function(){
+ return w.walk(ast);
+ });
+ return pro.gen_code(new_ast, { beautify: true });
+}
+
+
+////// test code follows.
+
+var code = instrument(test.toString());
+console.log(code);
+
+function test() {
+ // simple stats
+ a = 5;
+ c += a + b;
+ "foo";
+
+ // var
+ var foo = 5;
+ const bar = 6, baz = 7;
+
+ // switch block. note we can't track case lines the same way.
+ switch ("foo") {
+ case "foo":
+ return 1;
+ case "bar":
+ return 2;
+ }
+
+ // for/for in
+ for (var i = 0; i < 5; ++i) {
+ console.log("Hello " + i);
+ }
+ for (var i in [ 1, 2, 3]) {
+ console.log(i);
+ }
+
+ for (var i = 0; i < 5; ++i)
+ console.log("foo");
+
+ for (var i = 0; i < 5; ++i) {
+ console.log("foo");
+ }
+
+ var k = plurp() ? 1 : 0;
+ var x = a ? doX(y) && goZoo("zoo")
+ : b ? blerg({ x: y })
+ : null;
+
+ var x = X || Y;
+}
--- /dev/null
+//convienence function(src, [options]);
+function uglify(orig_code, options){
+ options || (options = {});
+ var jsp = uglify.parser;
+ var pro = uglify.uglify;
+
+ var ast = jsp.parse(orig_code, options.strict_semicolons); // parse code and get the initial AST
+ ast = pro.ast_mangle(ast, options.mangle_options); // get a new AST with mangled names
+ ast = pro.ast_squeeze(ast, options.squeeze_options); // get an AST with compression optimizations
+ var final_code = pro.gen_code(ast, options.gen_options); // compressed code here
+ return final_code;
+};
+
+uglify.parser = require("./lib/parse-js");
+uglify.uglify = require("./lib/process");
+
+module.exports = uglify
\ No newline at end of file
--- /dev/null
+info it worked if it ends with ok
+verbose cli [ 'node',
+verbose cli '/root/local/node/bin/npm',
+verbose cli 'install',
+verbose cli 'uglify-js' ]
+info using npm@1.0.15
+info using node@v0.4.10-pre
+verbose config file /root/.npmrc
+verbose config file /root/local/node/etc/npmrc
+silly testEngine { name: 'jade',
+silly testEngine description: 'Jade template engine',
+silly testEngine version: '0.13.0',
+silly testEngine author:
+silly testEngine { name: 'TJ Holowaychuk',
+silly testEngine email: 'tj@vision-media.ca' },
+silly testEngine repository:
+silly testEngine { type: 'git',
+silly testEngine url: 'git://github.com/visionmedia/jade.git' },
+silly testEngine main: './index.js',
+silly testEngine bin: { jade: './bin/jade' },
+silly testEngine devDependencies:
+silly testEngine { expresso: '0.6.4',
+silly testEngine 'coffee-script': '>= 0.0.1',
+silly testEngine sass: '>= 0.0.1',
+silly testEngine less: '>= 0.0.1',
+silly testEngine markdown: '>= 0.0.1',
+silly testEngine stylus: '>= 0.0.1' },
+silly testEngine scripts: { prepublish: 'npm prune' },
+silly testEngine engines: { node: '>= 0.1.98' },
+silly testEngine _npmJsonOpts:
+silly testEngine { file: '/var/www/kiwi/KiwiIRC/node/node_modules/jade/package.json',
+silly testEngine wscript: false,
+silly testEngine contributors: false,
+silly testEngine serverjs: false },
+silly testEngine _id: 'jade@0.13.0',
+silly testEngine dependencies: {},
+silly testEngine _engineSupported: true,
+silly testEngine _npmVersion: '1.0.15',
+silly testEngine _nodeVersion: 'v0.4.10-pre',
+silly testEngine _defaultsLoaded: true }
+verbose caching /var/www/kiwi/KiwiIRC/node/node_modules/jade/package.json
+verbose loadDefaults jade@0.13.0
+silly testEngine { name: 'node-static',
+silly testEngine description: 'simple, compliant file streaming module for node',
+silly testEngine url: 'http://github.com/cloudhead/node-static',
+silly testEngine keywords: [ 'http', 'static', 'file', 'server' ],
+silly testEngine author:
+silly testEngine { name: 'Alexis Sellier',
+silly testEngine email: 'self@cloudhead.net' },
+silly testEngine contributors: [],
+silly testEngine licenses: [ 'MIT' ],
+silly testEngine dependencies: {},
+silly testEngine lib: 'lib',
+silly testEngine main: './lib/node-static',
+silly testEngine version: '0.5.6',
+silly testEngine directories: { test: './test' },
+silly testEngine engines: { node: '>= 0.4.1' },
+silly testEngine _npmJsonOpts:
+silly testEngine { file: '/var/www/kiwi/KiwiIRC/node/node_modules/node-static/package.json',
+silly testEngine wscript: false,
+silly testEngine contributors: false,
+silly testEngine serverjs: false },
+silly testEngine _id: 'node-static@0.5.6',
+silly testEngine devDependencies: {},
+silly testEngine _engineSupported: true,
+silly testEngine _npmVersion: '1.0.15',
+silly testEngine _nodeVersion: 'v0.4.10-pre',
+silly testEngine _defaultsLoaded: true }
+verbose caching /var/www/kiwi/KiwiIRC/node/node_modules/node-static/package.json
+verbose loadDefaults node-static@0.5.6
+silly testEngine { name: 'socket.io',
+silly testEngine version: '0.7.7',
+silly testEngine description: 'Real-time apps made cross-browser & easy with a WebSocket-like API',
+silly testEngine homepage: 'http://socket.io',
+silly testEngine keywords:
+silly testEngine [ 'websocket',
+silly testEngine 'socket',
+silly testEngine 'realtime',
+silly testEngine 'socket.io',
+silly testEngine 'comet',
+silly testEngine 'ajax' ],
+silly testEngine author:
+silly testEngine { name: 'Guillermo Rauch',
+silly testEngine email: 'guillermo@learnboost.com' },
+silly testEngine contributors:
+silly testEngine [ { name: 'Guillermo Rauch', email: 'rauchg@gmail.com' },
+silly testEngine { name: 'Arnout Kazemier',
+silly testEngine email: 'info@3rd-eden.com' },
+silly testEngine { name: 'Vladimir Dronnikov',
+silly testEngine email: 'dronnikov@gmail.com' } ],
+silly testEngine repository:
+silly testEngine { type: 'git',
+silly testEngine url: 'git://github.com/LearnBoost/Socket.IO-node.git' },
+silly testEngine dependencies:
+silly testEngine { 'socket.io-client': '0.7.4',
+silly testEngine policyfile: '0.0.3',
+silly testEngine redis: '0.6.0' },
+silly testEngine devDependencies: { expresso: '0.7.7', should: '0.0.4' },
+silly testEngine main: 'index',
+silly testEngine engines: { node: '>= 0.4.0' },
+silly testEngine _npmJsonOpts:
+silly testEngine { file: '/var/www/kiwi/KiwiIRC/node/node_modules/socket.io/package.json',
+silly testEngine wscript: false,
+silly testEngine contributors: false,
+silly testEngine serverjs: false },
+silly testEngine _id: 'socket.io@0.7.7',
+silly testEngine _engineSupported: true,
+silly testEngine _npmVersion: '1.0.15',
+silly testEngine _nodeVersion: 'v0.4.10-pre',
+silly testEngine _defaultsLoaded: true }
+verbose caching /var/www/kiwi/KiwiIRC/node/node_modules/socket.io/package.json
+verbose loadDefaults socket.io@0.7.7
+silly testEngine { name: 'socket.io-client',
+silly testEngine description: 'Socket.IO client for the browser and node.js',
+silly testEngine version: '0.7.4',
+silly testEngine main: './lib/io.js',
+silly testEngine browserify: './dist/socket.io.js',
+silly testEngine homepage: 'http://socket.io',
+silly testEngine keywords:
+silly testEngine [ 'websocket',
+silly testEngine 'socket',
+silly testEngine 'realtime',
+silly testEngine 'socket.io',
+silly testEngine 'comet',
+silly testEngine 'ajax' ],
+silly testEngine author:
+silly testEngine { name: 'Guillermo Rauch',
+silly testEngine email: 'guillermo@learnboost.com' },
+silly testEngine contributors:
+silly testEngine [ { name: 'Guillermo Rauch', email: 'rauchg@gmail.com' },
+silly testEngine { name: 'Arnout Kazemier',
+silly testEngine email: 'info@3rd-eden.com' },
+silly testEngine { name: 'Vladimir Dronnikov',
+silly testEngine email: 'dronnikov@gmail.com' } ],
+silly testEngine repository:
+silly testEngine { type: 'git',
+silly testEngine url: 'git://github.com/LearnBoost/Socket.IO.git' },
+silly testEngine dependencies: { 'uglify-js': '1.0.3' },
+silly testEngine devDependencies:
+silly testEngine { expresso: '0.7.7',
+silly testEngine express: '2.3.11',
+silly testEngine jade: '0.12.1',
+silly testEngine stylus: '0.13.3',
+silly testEngine 'socket.io': '0.7.7',
+silly testEngine 'socket.io-client': '0.7.4' },
+silly testEngine engines: { node: '>= 0.4.0' },
+silly testEngine _npmJsonOpts:
+silly testEngine { file: '/var/www/kiwi/KiwiIRC/node/node_modules/socket.io-client/package.json',
+silly testEngine wscript: false,
+silly testEngine contributors: false,
+silly testEngine serverjs: false },
+silly testEngine _id: 'socket.io-client@0.7.4',
+silly testEngine _engineSupported: true,
+silly testEngine _npmVersion: '1.0.15',
+silly testEngine _nodeVersion: 'v0.4.10-pre',
+silly testEngine _defaultsLoaded: true }
+verbose caching /var/www/kiwi/KiwiIRC/node/node_modules/socket.io-client/package.json
+verbose loadDefaults socket.io-client@0.7.4
+verbose into /var/www/kiwi/KiwiIRC/node [ 'uglify-js' ]
+verbose cache add [ 'uglify-js', null ]
+info addNamed [ 'uglify-js', '' ]
+verbose addNamed [ null, '' ]
+verbose GET uglify-js
+verbose raw, before any munging uglify-js
+verbose url resolving [ 'http://registry.npmjs.org/', './uglify-js' ]
+verbose url resolved http://registry.npmjs.org/uglify-js
+verbose url parsed { protocol: 'http:',
+verbose url parsed slashes: true,
+verbose url parsed host: 'registry.npmjs.org',
+verbose url parsed hostname: 'registry.npmjs.org',
+verbose url parsed href: 'http://registry.npmjs.org/uglify-js',
+verbose url parsed pathname: '/uglify-js' }
+verbose response http://registry.npmjs.org/uglify-js
+silly chunk {"_id":"uglify-js","_rev":"26-8064181b8cb5259cdda963e8c227c8d7","name":"uglify-js","dist-tags":{"latest":"1.0.6"},"versions":{"0.0.1":{"name":"uglify-js","author":{"name":"Mihai Bazon - http://github.com/mishoo"},"version":"0.0.1","main":"index","bin":{"uglifyjs":"./bin/uglifyjs"},"_id":"uglify-js@0.0.1","engines":{"node":"*"},"_nodeSupported":true,"_npmVersion":"0.2.7-2","_nodeVersion":"v0.2.4","dist":{"tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-0.0.1.tgz"},"directories":{}},"0.0.2":{"name":"uglify-js","author":{"name":"Mihai Bazon - http://github.com/mishoo"},"version":"0.0.2","main":"index","bin":{"uglifyjs":"./bin/uglifyjs"},"_id":"uglify-js@0.0.2","engines":{"node":"*"},"_nodeSupported":true,"_npmVersion":"0.2.12-1","_nodeVersion":"v0.3.5-pre","dist":{"shasum":"baaf5c2223440d31f008bd248aaa728e8c771a8a","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-0.0.2.tgz"},"directories":{}},"0.0.3":{"name":"uglify-js","author":{"name":"Mihai Bazon - http://github.com/mishoo"},"version":"0.0.3","main":"index","bin":{"uglifyjs":"./bin/uglifyjs"},"_id":"uglify-js@0.0.3","engines":{"node":"*"},"_nodeSupported":true,"_npmVersion":"0.2.12-1","_nodeVersion":"v0.3.5-pre","dist":{"shasum":"04e48708cb7175fba8b23aba7596e39c849ccfab","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-0.0.3.tgz"},"directories":{}},"0.0.4":{"name":"uglify-js",
+silly chunk "author":{"name":"Mihai Bazon - http://github.com/mishoo"},"version":"0.0.4","main":"index","bin":{"uglifyjs":"./bin/uglifyjs"},"_id":"uglify-js@0.0.4","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"0.2.17","_nodeVersion":"v0.3.8-pre","directories":{"lib":"./lib","bin":"./bin"},"files":[""],"_defaultsLoaded":true,"dist":{"shasum":"48b2d19b65c284a82c4d6ccab6ed141b8e313a72","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-0.0.4.tgz"}},"0.0.5":{"name":"uglify-js","author":{"name":"Mihai Bazon - http://github.com/mishoo"},"version":"0.0.5","main":"index.js","bin":{"uglifyjs":"./bin/uglifyjs"},"_id":"uglify-js@0.0.5","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"0.3.3","_nodeVersion":"v0.4.1","directories":{"lib":"./lib","bin":"./bin"},"files":[""],"_defaultsLoaded":true,"dist":{"shasum":"c40d18e51784a230477bb0354fa415ec361dba5e","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-0.0.5.tgz"}},"1.0.1":{"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"version":"1.0.1","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.1","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"
+silly chunk v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"b34b3220e7d634401f388c8bd69e9663cec6ca94","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.1.tgz"},"directories":{}},"1.0.2":{"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"version":"1.0.2","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.2","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"28494cc77c26042d4065d73736391d78417d680a","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.2.tgz"},"directories":{}},"1.0.3":{"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"version":"1.0.3","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.3","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"73c4f09bcec47ec5e8669cb37c11b95b7014f945","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-
+silly chunk 1.0.3.tgz"},"directories":{}},"1.0.4":{"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"version":"1.0.4","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.4","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"7512dbbfca85e749683800c65407e55491700778","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.4.tgz"},"directories":{}},"1.0.5":{"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"version":"1.0.5","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.5","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"25679bdcff52f9500774a644cef3129b8ddb5cf2","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.5.tgz"},"directories":{}},"1.0.6":{"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blo
+silly chunk g"},"version":"1.0.6","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.6","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"f0d3aafd463f26a437b9ebc19f4947ab7e8078aa","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.6.tgz"},"directories":{}}},"maintainers":[{"name":"caires","email":"cairesvs@gmail.com"},{"name":"mape","email":"mape@mape.me"},{"name":"mishoo","email":"mihai.bazon@gmail.com"}],"author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"time":{"0.0.1":"2011-01-05T17:56:48.593Z","0.0.2":"2011-01-09T13:47:55.729Z","0.0.3":"2011-01-25T05:53:18.848Z","0.0.4":"2011-02-05T13:28:37.926Z","0.0.5":"2011-02-20T16:37:04.786Z","1.0.1":"2011-04-03T22:03:32.396Z","1.0.2":"2011-05-19T16:13:13.281Z","1.0.3":"2011-06-27T16:52:42.404Z","1.0.4":"2011-07-01T10:26:41.824Z","1.0.5":"2011-07-14T09:54:00.537Z","1.0.6":"2011-07-14T20:36:30.484Z"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"}}
+silly get cb [ 200,
+silly get cb { vary: 'Accept',
+silly get cb server: 'CouchDB/1.1.0 (Erlang OTP/R14B03)',
+silly get cb etag: '"2CZS2DKWM45Z3WMB02DQSV95J"',
+silly get cb date: 'Sat, 23 Jul 2011 12:25:08 GMT',
+silly get cb 'content-type': 'application/json',
+silly get cb 'content-length': '6718' } ]
+verbose GET uglify-js/1.0.6
+verbose raw, before any munging uglify-js/1.0.6
+verbose url resolving [ 'http://registry.npmjs.org/', './uglify-js/1.0.6' ]
+verbose url resolved http://registry.npmjs.org/uglify-js/1.0.6
+verbose url parsed { protocol: 'http:',
+verbose url parsed slashes: true,
+verbose url parsed host: 'registry.npmjs.org',
+verbose url parsed hostname: 'registry.npmjs.org',
+verbose url parsed href: 'http://registry.npmjs.org/uglify-js/1.0.6',
+verbose url parsed pathname: '/uglify-js/1.0.6' }
+verbose response http://registry.npmjs.org/uglify-js/1.0.6
+silly chunk {"name":"uglify-js","author":{"name":"Mihai Bazon","email":"mihai.bazon@gmail.com","url":"http://mihai.bazon.net/blog"},"version":"1.0.6","main":"./uglify-js.js","bin":{"uglifyjs":"./bin/uglifyjs"},"repository":{"type":"git","url":"git@github.com:mishoo/UglifyJS.git"},"dependencies":{},"devDependencies":{},"_id":"uglify-js@1.0.6","engines":{"node":"*"},"_engineSupported":true,"_npmVersion":"1.0.1rc5","_nodeVersion":"v0.5.0-pre","_defaultsLoaded":true,"dist":{"shasum":"f0d3aafd463f26a437b9ebc19f4947ab7e8078aa","tarball":"http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.6.tgz"},"directories":{}}
+silly get cb [ 200,
+silly get cb { vary: 'Accept',
+silly get cb server: 'CouchDB/1.1.0 (Erlang OTP/R14B03)',
+silly get cb etag: '"2CZS2DKWM45Z3WMB02DQSV95J"',
+silly get cb date: 'Sat, 23 Jul 2011 12:25:09 GMT',
+silly get cb 'content-type': 'application/json',
+silly get cb 'content-length': '603' } ]
+verbose mkdir done: /root/.npm/uglify-js/1.0.6 755
+verbose bin dist [ '0.4-ares1.7.4-ev4.4-openssl0.9.8o-v83.1.8.25-linux-2.6.35-30-generic',
+verbose bin dist { shasum: 'f0d3aafd463f26a437b9ebc19f4947ab7e8078aa',
+verbose bin dist tarball: 'http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.6.tgz' } ]
+verbose addRemoteTarball [ 'http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.6.tgz',
+verbose addRemoteTarball 'f0d3aafd463f26a437b9ebc19f4947ab7e8078aa' ]
+verbose mkdir done: /tmp/npm-1311423850738/1311423850738-0.8425169289112091 755
+info fetch http://registry.npmjs.org/uglify-js/-/uglify-js-1.0.6.tgz
+verbose fetch to /tmp/npm-1311423850738/1311423850738-0.8425169289112091/tmp.tgz
+silly updated sha bytes 40960
+silly updated sha bytes 12084
+info shasum f0d3aafd463f26a437b9ebc19f4947ab7e8078aa
+info shasum /tmp/npm-1311423850738/1311423850738-0.8425169289112091/tmp.tgz
+verbose mkdir done: /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm 755
+verbose unpack_ uid, gid [ 1000, 1000 ]
+verbose unpackTarget /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package
+silly gunzTarPerm modes [ '755', '644' ]
+verbose success gzip "--decompress" "--stdout" "/tmp/npm-1311423850738/1311423850738-0.8425169289112091/tmp.tgz"
+verbose success tar "-mvxpf" "-" "--no-same-owner" "-C" "/tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm"
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/uglify-js.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/docstyle.css
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/package.json
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/README.html
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/README.org
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/.gitignore
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/bin/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/bin/uglifyjs
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/tmp/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/tmp/instrument2.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/tmp/instrument.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/lib/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/lib/parse-js.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/lib/squeeze-more.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/lib/process.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/testparser.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/beautify.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/scripts.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue68.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue10.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue30.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue21.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue13.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue28.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue50.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/array3.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/concatstring.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue17.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue11.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/assignment.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/var.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/if.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/empty-blocks.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue16.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue53.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/with.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/ifreturn2.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue14.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue48.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/mangle.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/array1.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue20.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/array4.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue25.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue54.1.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/const.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/strict-equals.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue27.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue69.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/forstatement.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue29.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/array2.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue9.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/ifreturn.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue34.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/expected/issue4.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue68.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue10.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue30.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue21.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue13.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue28.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue50.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/array3.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/concatstring.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue17.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue11.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/assignment.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/var.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/if.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/empty-blocks.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue16.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue53.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/with.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/ifreturn2.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue14.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue48.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/mangle.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/array1.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue20.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/array4.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue25.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue54.1.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/const.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/strict-equals.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue27.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue69.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/forstatement.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue29.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/array2.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue9.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/ifreturn.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue34.js
+silly asyncMap in gTP /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package/test/unit/compress/test/issue4.js
+verbose gunzed /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package
+verbose rm'ed /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package
+verbose renamed [ '/tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/___package.npm/package',
+verbose renamed '/tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package' ]
+silly testEngine { name: 'uglify-js',
+silly testEngine author:
+silly testEngine { name: 'Mihai Bazon',
+silly testEngine email: 'mihai.bazon@gmail.com',
+silly testEngine url: 'http://mihai.bazon.net/blog' },
+silly testEngine version: '1.0.6',
+silly testEngine main: './uglify-js.js',
+silly testEngine bin: { uglifyjs: './bin/uglifyjs' },
+silly testEngine repository:
+silly testEngine { type: 'git',
+silly testEngine url: 'git@github.com:mishoo/UglifyJS.git' },
+silly testEngine _npmJsonOpts:
+silly testEngine { file: '/tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package/package.json',
+silly testEngine wscript: false,
+silly testEngine contributors: false,
+silly testEngine serverjs: false },
+silly testEngine _id: 'uglify-js@1.0.6',
+silly testEngine dependencies: {},
+silly testEngine devDependencies: {},
+silly testEngine engines: { node: '*' },
+silly testEngine _engineSupported: true,
+silly testEngine _npmVersion: '1.0.15',
+silly testEngine _nodeVersion: 'v0.4.10-pre',
+silly testEngine _defaultsLoaded: true,
+silly testEngine path: '/tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package' }
+verbose caching /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package/package.json
+verbose loadDefaults uglify-js@1.0.6
+verbose tarball contents [ 'package' ]
+verbose from cache /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package/package.json
+verbose pack /tmp/npm-1311423850738/1311423850738-0.8425169289112091/contents/package /root/.npm/uglify-js/1.0.6/package.tgz
+verbose mkdir'ed /root/.npm/uglify-js/1.0.6
+verbose tar about to write tar and gzip it.
+silly tar args [ '-cvf',
+silly tar args '-',
+silly tar args 'package/uglify-js.js',
+silly tar args 'package/docstyle.css',
+silly tar args 'package/package.json',
+silly tar args 'package/README.html',
+silly tar args 'package/README.org',
+silly tar args 'package/.gitignore',
+silly tar args 'package/bin/uglifyjs',
+silly tar args 'package/tmp/instrument2.js',
+silly tar args 'package/tmp/instrument.js',
+silly tar args 'package/lib/parse-js.js',
+silly tar args 'package/lib/squeeze-more.js',
+silly tar args 'package/lib/process.js',
+silly tar args 'package/test/testparser.js',
+silly tar args 'package/test/beautify.js',
+silly tar args 'package/test/unit/scripts.js',
+silly tar args 'package/test/unit/compress/expected/issue68.js',
+silly tar args 'package/test/unit/compress/expected/issue10.js',
+silly tar args 'package/test/unit/compress/expected/issue30.js',
+silly tar args 'package/test/unit/compress/expected/issue21.js',
+silly tar args 'package/test/unit/compress/expected/issue13.js',
+silly tar args 'package/test/unit/compress/expected/issue28.js',
+silly tar args 'package/test/unit/compress/expected/issue50.js',
+silly tar args 'package/test/unit/compress/expected/array3.js',
+silly tar args 'package/test/unit/compress/expected/concatstring.js',
+silly tar args 'package/test/unit/compress/expected/issue17.js',
+silly tar args 'package/test/unit/compress/expected/issue11.js',
+silly tar args 'package/test/unit/compress/expected/assignment.js',
+silly tar args 'package/test/unit/compress/expected/var.js',
+silly tar args 'package/test/unit/compress/expected/if.js',
+silly tar args 'package/test/unit/compress/expected/empty-blocks.js',
+silly tar args 'package/test/unit/compress/expected/issue16.js',
+silly tar args 'package/test/unit/compress/expected/issue53.js',
+silly tar args 'package/test/unit/compress/expected/with.js',
+silly tar args 'package/test/unit/compress/expected/ifreturn2.js',
+silly tar args 'package/test/unit/compress/expected/issue14.js',
+silly tar args 'package/test/unit/compress/expected/issue48.js',
+silly tar args 'package/test/unit/compress/expected/mangle.js',
+silly tar args 'package/test/unit/compress/expected/array1.js',
+silly tar args 'package/test/unit/compress/expected/issue20.js',
+silly tar args 'package/test/unit/compress/expected/array4.js',
+silly tar args 'package/test/unit/compress/expected/issue25.js',
+silly tar args 'package/test/unit/compress/expected/issue54.1.js',
+silly tar args 'package/test/unit/compress/expected/const.js',
+silly tar args 'package/test/unit/compress/expected/strict-equals.js',
+silly tar args 'package/test/unit/compress/expected/issue27.js',
+silly tar args 'package/test/unit/compress/expected/issue69.js',
+silly tar args 'package/test/unit/compress/expected/forstatement.js',
+silly tar args 'package/test/unit/compress/expected/issue29.js',
+silly tar args 'package/test/unit/compress/expected/array2.js',
+silly tar args 'package/test/unit/compress/expected/issue9.js',
+silly tar args 'package/test/unit/compress/expected/ifreturn.js',
+silly tar args 'package/test/unit/compress/expected/issue34.js',
+silly tar args 'package/test/unit/compress/expected/issue4.js',
+silly tar args 'package/test/unit/compress/test/issue68.js',
+silly tar args 'package/test/unit/compress/test/issue10.js',
+silly tar args 'package/test/unit/compress/test/issue30.js',
+silly tar args 'package/test/unit/compress/test/issue21.js',
+silly tar args 'package/test/unit/compress/test/issue13.js',
+silly tar args 'package/test/unit/compress/test/issue28.js',
+silly tar args 'package/test/unit/compress/test/issue50.js',
+silly tar args 'package/test/unit/compress/test/array3.js',
+silly tar args 'package/test/unit/compress/test/concatstring.js',
+silly tar args 'package/test/unit/compress/test/issue17.js',
+silly tar args 'package/test/unit/compress/test/issue11.js',
+silly tar args 'package/test/unit/compress/test/assignment.js',
+silly tar args 'package/test/unit/compress/test/var.js',
+silly tar args 'package/test/unit/compress/test/if.js',
+silly tar args 'package/test/unit/compress/test/empty-blocks.js',
+silly tar args 'package/test/unit/compress/test/issue16.js',
+silly tar args 'package/test/unit/compress/test/issue53.js',
+silly tar args 'package/test/unit/compress/test/with.js',
+silly tar args 'package/test/unit/compress/test/ifreturn2.js',
+silly tar args 'package/test/unit/compress/test/issue14.js',
+silly tar args 'package/test/unit/compress/test/issue48.js',
+silly tar args 'package/test/unit/compress/test/mangle.js',
+silly tar args 'package/test/unit/compress/test/array1.js',
+silly tar args 'package/test/unit/compress/test/issue20.js',
+silly tar args 'package/test/unit/compress/test/array4.js',
+silly tar args 'package/test/unit/compress/test/issue25.js',
+silly tar args 'package/test/unit/compress/test/issue54.1.js',
+silly tar args 'package/test/unit/compress/test/const.js',
+silly tar args 'package/test/unit/compress/test/strict-equals.js',
+silly tar args 'package/test/unit/compress/test/issue27.js',
+silly tar args 'package/test/unit/compress/test/issue69.js',
+silly tar args 'package/test/unit/compress/test/forstatement.js',
+silly tar args 'package/test/unit/compress/test/issue29.js',
+silly tar args 'package/test/unit/compress/test/array2.js',
+silly tar args 'package/test/unit/compress/test/issue9.js',
+silly tar args 'package/test/unit/compress/test/ifreturn.js',
+silly tar args 'package/test/unit/compress/test/issue34.js',
+silly tar args 'package/test/unit/compress/test/issue4.js' ]
+verbose success tar -cvf - <file list elided>
+verbose success gzip "--stdout"
+verbose mkdir done: /root/.npm/uglify-js/1.0.6/___package.npm 755
+verbose unpack_ uid, gid [ 1000, 1000 ]
+verbose unpackTarget /root/.npm/uglify-js/1.0.6/package
+silly gunzTarPerm modes [ '755', '644' ]
+verbose success gzip "--decompress" "--stdout" "/root/.npm/uglify-js/1.0.6/package.tgz"
+verbose success tar "-mvxpf" "-" "--no-same-owner" "-C" "/root/.npm/uglify-js/1.0.6/___package.npm"
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/uglify-js.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/docstyle.css
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/package.json
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/README.html
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/README.org
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/.gitignore
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/bin/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/bin/uglifyjs
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/lib/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/lib/parse-js.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/lib/squeeze-more.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/lib/process.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/tmp/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/tmp/instrument2.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/tmp/instrument.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/testparser.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/beautify.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/scripts.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue68.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue10.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue30.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue21.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue13.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue28.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue50.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/array3.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/concatstring.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue17.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue11.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/assignment.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/var.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/if.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/empty-blocks.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue16.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue53.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/with.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/ifreturn2.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue14.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue48.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/mangle.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/array1.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue20.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/array4.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue25.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue54.1.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/const.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/strict-equals.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue27.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue69.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/forstatement.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue29.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/array2.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue9.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/ifreturn.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue34.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/expected/issue4.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue68.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue10.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue30.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue21.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue13.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue28.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue50.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/array3.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/concatstring.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue17.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue11.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/assignment.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/var.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/if.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/empty-blocks.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue16.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue53.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/with.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/ifreturn2.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue14.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue48.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/mangle.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/array1.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue20.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/array4.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue25.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue54.1.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/const.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/strict-equals.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue27.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue69.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/forstatement.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue29.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/array2.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue9.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/ifreturn.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue34.js
+silly asyncMap in gTP /root/.npm/uglify-js/1.0.6/___package.npm/package/test/unit/compress/test/issue4.js
+verbose gunzed /root/.npm/uglify-js/1.0.6/___package.npm/package
+verbose rm'ed /root/.npm/uglify-js/1.0.6/package
+verbose renamed [ '/root/.npm/uglify-js/1.0.6/___package.npm/package',
+verbose renamed '/root/.npm/uglify-js/1.0.6/package' ]
+silly testEngine { name: 'uglify-js',
+silly testEngine author:
+silly testEngine { name: 'Mihai Bazon',
+silly testEngine email: 'mihai.bazon@gmail.com',
+silly testEngine url: 'http://mihai.bazon.net/blog' },
+silly testEngine version: '1.0.6',
+silly testEngine main: './uglify-js.js',
+silly testEngine bin: { uglifyjs: './bin/uglifyjs' },
+silly testEngine repository:
+silly testEngine { type: 'git',
+silly testEngine url: 'git@github.com:mishoo/UglifyJS.git' },
+silly testEngine _npmJsonOpts:
+silly testEngine { file: '/root/.npm/uglify-js/1.0.6/package/package.json',
+silly testEngine wscript: false,
+silly testEngine contributors: false,
+silly testEngine serverjs: false },
+silly testEngine _id: 'uglify-js@1.0.6',
+silly testEngine dependencies: {},
+silly testEngine devDependencies: {},
+silly testEngine engines: { node: '*' },
+silly testEngine _engineSupported: true,
+silly testEngine _npmVersion: '1.0.15',
+silly testEngine _nodeVersion: 'v0.4.10-pre',
+silly testEngine _defaultsLoaded: true,
+silly testEngine dist: { shasum: 'eabbc5c1ccc65c6cb0f337ae43ecdf2be277cd8e' } }
+verbose caching /root/.npm/uglify-js/1.0.6/package/package.json
+verbose loadDefaults uglify-js@1.0.6
+silly updated sha bytes 40960
+silly updated sha bytes 12384
+info shasum eabbc5c1ccc65c6cb0f337ae43ecdf2be277cd8e
+info shasum /root/.npm/uglify-js/1.0.6/package.tgz
+verbose from cache /root/.npm/uglify-js/1.0.6/package/package.json
+verbose chmod /root/.npm/uglify-js/1.0.6/package.tgz 644
+silly resolved [ { name: 'uglify-js',
+silly resolved author:
+silly resolved { name: 'Mihai Bazon',
+silly resolved email: 'mihai.bazon@gmail.com',
+silly resolved url: 'http://mihai.bazon.net/blog' },
+silly resolved version: '1.0.6',
+silly resolved main: './uglify-js.js',
+silly resolved bin: { uglifyjs: './bin/uglifyjs' },
+silly resolved repository:
+silly resolved { type: 'git',
+silly resolved url: 'git@github.com:mishoo/UglifyJS.git' },
+silly resolved _npmJsonOpts:
+silly resolved { file: '/root/.npm/uglify-js/1.0.6/package/package.json',
+silly resolved wscript: false,
+silly resolved contributors: false,
+silly resolved serverjs: false },
+silly resolved _id: 'uglify-js@1.0.6',
+silly resolved dependencies: {},
+silly resolved devDependencies: {},
+silly resolved engines: { node: '*' },
+silly resolved _engineSupported: true,
+silly resolved _npmVersion: '1.0.15',
+silly resolved _nodeVersion: 'v0.4.10-pre',
+silly resolved _defaultsLoaded: true,
+silly resolved dist: { shasum: 'eabbc5c1ccc65c6cb0f337ae43ecdf2be277cd8e' } } ]
+info into /var/www/kiwi/KiwiIRC/node uglify-js@1.0.6
+info installOne uglify-js@1.0.6
+info unbuild /var/www/kiwi/KiwiIRC/node/node_modules/uglify-js
+verbose from cache /root/.npm/uglify-js/1.0.6/package/package.json
+verbose mkdir done: /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm 755
+verbose unpack_ uid, gid [ 1000, 1000 ]
+verbose unpackTarget /var/www/kiwi/KiwiIRC/node/node_modules/uglify-js
+silly gunzTarPerm modes [ '755', '644' ]
+verbose success gzip "--decompress" "--stdout" "/root/.npm/uglify-js/1.0.6/package.tgz"
+verbose success tar "-mvxpf" "-" "--no-same-owner" "-C" "/var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm"
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/.gitignore
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/docstyle.css
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/package.json
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/README.html
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/README.org
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/uglify-js.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/bin/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/bin/uglifyjs
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/tmp/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/tmp/instrument.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/tmp/instrument2.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/lib/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/lib/parse-js.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/lib/process.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/lib/squeeze-more.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/beautify.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/testparser.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/scripts.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/array1.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/array2.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/array3.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/array4.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/assignment.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/concatstring.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/const.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/empty-blocks.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/forstatement.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/if.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/ifreturn.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/ifreturn2.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue10.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue11.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue13.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue14.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue16.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue17.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue20.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue21.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue25.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue27.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue28.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue29.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue30.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue34.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue4.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue48.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue50.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue53.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue54.1.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue68.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue69.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/issue9.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/mangle.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/strict-equals.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/var.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/test/with.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/array1.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/array2.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/array3.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/array4.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/assignment.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/concatstring.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/const.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/empty-blocks.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/forstatement.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/if.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/ifreturn.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/ifreturn2.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue10.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue11.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue13.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue14.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue16.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue17.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue20.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue21.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue25.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue27.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue28.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue29.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue30.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue34.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue4.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue48.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue50.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue53.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue54.1.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue68.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue69.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/issue9.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/mangle.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/strict-equals.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/var.js
+silly asyncMap in gTP /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package/test/unit/compress/expected/with.js
+verbose gunzed /var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package
+verbose rm'ed /var/www/kiwi/KiwiIRC/node/node_modules/uglify-js
+ERR! error installing uglify-js@1.0.6 Error: EACCES, Permission denied '/var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package'
+info unbuild /var/www/kiwi/KiwiIRC/node/node_modules/uglify-js
+verbose installOne cb uglify-js@1.0.6
+ERR! Error: EACCES, Permission denied '/var/www/kiwi/KiwiIRC/node/node_modules/___uglify-js.npm/package'
+ERR!
+ERR! Please use 'sudo' or log in as root to run this command.
+ERR! sudo npm "install" "uglify-js"
+ERR! or set the 'unsafe-perm' config var to true.
+ERR! npm config set unsafe-perm true
+ERR!
+ERR! System Linux 2.6.35-30-generic
+ERR! command "node" "/root/local/node/bin/npm" "install" "uglify-js"
+verbose exit [ 13, true ]
projects / KiwiIRC.git / commitdiff