Browse files

Adding sources.

  • Loading branch information...
1 parent 4947a40 commit 64a58eb67ddd0a4d8d371d9543a542fd21c9bb04 @efeminella committed Apr 16, 2012
Showing with 43,549 additions and 0 deletions.
  1. +1 −0 backbone-eventbroker-min.js
  2. +36 −0 build/build.js
  3. +332 −0 build/node_modules/.bin/uglifyjs
  4. +4 −0 build/node_modules/uglify-js/.npmignore
  5. +981 −0 build/node_modules/uglify-js/README.html
  6. +578 −0 build/node_modules/uglify-js/README.org
  7. +332 −0 build/node_modules/uglify-js/bin/uglifyjs
  8. +75 −0 build/node_modules/uglify-js/docstyle.css
  9. +2,599 −0 build/node_modules/uglify-js/lib/consolidator.js
  10. +75 −0 build/node_modules/uglify-js/lib/object-ast.js
  11. +1,346 −0 build/node_modules/uglify-js/lib/parse-js.js
  12. +2,011 −0 build/node_modules/uglify-js/lib/process.js
  13. +73 −0 build/node_modules/uglify-js/lib/squeeze-more.js
  14. +24 −0 build/node_modules/uglify-js/package.json
  15. +24 −0 build/node_modules/uglify-js/package.json~
  16. +28 −0 build/node_modules/uglify-js/test/beautify.js
  17. +403 −0 build/node_modules/uglify-js/test/testparser.js
  18. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/array1.js
  19. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/array2.js
  20. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/array3.js
  21. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/array4.js
  22. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/assignment.js
  23. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/concatstring.js
  24. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/const.js
  25. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/empty-blocks.js
  26. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/forstatement.js
  27. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/if.js
  28. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/ifreturn.js
  29. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/ifreturn2.js
  30. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue10.js
  31. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue11.js
  32. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue13.js
  33. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue14.js
  34. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue16.js
  35. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue17.js
  36. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue20.js
  37. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue21.js
  38. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue25.js
  39. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue27.js
  40. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue278.js
  41. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue28.js
  42. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue29.js
  43. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue30.js
  44. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue34.js
  45. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue4.js
  46. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue48.js
  47. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue50.js
  48. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue53.js
  49. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue54.1.js
  50. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue68.js
  51. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue69.js
  52. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/issue9.js
  53. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/mangle.js
  54. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/null_string.js
  55. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/strict-equals.js
  56. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/var.js
  57. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/whitespace.js
  58. +1 −0 build/node_modules/uglify-js/test/unit/compress/expected/with.js
  59. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/array1.js
  60. +4 −0 build/node_modules/uglify-js/test/unit/compress/test/array2.js
  61. +4 −0 build/node_modules/uglify-js/test/unit/compress/test/array3.js
  62. +6 −0 build/node_modules/uglify-js/test/unit/compress/test/array4.js
  63. +20 −0 build/node_modules/uglify-js/test/unit/compress/test/assignment.js
  64. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/concatstring.js
  65. +5 −0 build/node_modules/uglify-js/test/unit/compress/test/const.js
  66. +4 −0 build/node_modules/uglify-js/test/unit/compress/test/empty-blocks.js
  67. +10 −0 build/node_modules/uglify-js/test/unit/compress/test/forstatement.js
  68. +6 −0 build/node_modules/uglify-js/test/unit/compress/test/if.js
  69. +9 −0 build/node_modules/uglify-js/test/unit/compress/test/ifreturn.js
  70. +16 −0 build/node_modules/uglify-js/test/unit/compress/test/ifreturn2.js
  71. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue10.js
  72. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/issue11.js
  73. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue13.js
  74. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue14.js
  75. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue16.js
  76. +4 −0 build/node_modules/uglify-js/test/unit/compress/test/issue17.js
  77. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue20.js
  78. +6 −0 build/node_modules/uglify-js/test/unit/compress/test/issue21.js
  79. +7 −0 build/node_modules/uglify-js/test/unit/compress/test/issue25.js
  80. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue27.js
  81. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue278.js
  82. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/issue28.js
  83. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue29.js
  84. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/issue30.js
  85. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/issue34.js
  86. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/issue4.js
  87. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue48.js
  88. +9 −0 build/node_modules/uglify-js/test/unit/compress/test/issue50.js
  89. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue53.js
  90. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/issue54.1.js
  91. +5 −0 build/node_modules/uglify-js/test/unit/compress/test/issue68.js
  92. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/issue69.js
  93. +4 −0 build/node_modules/uglify-js/test/unit/compress/test/issue9.js
  94. +5 −0 build/node_modules/uglify-js/test/unit/compress/test/mangle.js
  95. +1 −0 build/node_modules/uglify-js/test/unit/compress/test/null_string.js
  96. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/strict-equals.js
  97. +3 −0 build/node_modules/uglify-js/test/unit/compress/test/var.js
  98. +21 −0 build/node_modules/uglify-js/test/unit/compress/test/whitespace.js
  99. +2 −0 build/node_modules/uglify-js/test/unit/compress/test/with.js
  100. +55 −0 build/node_modules/uglify-js/test/unit/scripts.js
  101. +13 −0 build/node_modules/uglify-js/tmp/269.js
  102. +22,315 −0 build/node_modules/uglify-js/tmp/app.js
  103. +15 −0 build/node_modules/uglify-js/tmp/embed-tokens.js
  104. +26 −0 build/node_modules/uglify-js/tmp/goto.js
  105. +8 −0 build/node_modules/uglify-js/tmp/goto2.js
  106. +33 −0 build/node_modules/uglify-js/tmp/hoist.js
  107. +97 −0 build/node_modules/uglify-js/tmp/instrument.js
  108. +138 −0 build/node_modules/uglify-js/tmp/instrument2.js
  109. +8 −0 build/node_modules/uglify-js/tmp/liftvars.js
  110. +30 −0 build/node_modules/uglify-js/tmp/test.js
  111. +3,930 −0 build/node_modules/uglify-js/tmp/uglify-hangs.js
  112. +166 −0 build/node_modules/uglify-js/tmp/uglify-hangs2.js
  113. +18 −0 build/node_modules/uglify-js/uglify-js.js
  114. +211 −0 spec/backbone-eventbroker-spec.js
  115. +26 −0 spec/spec-runner.html
  116. +224 −0 src/backbone-eventbroker.js
  117. +37 −0 vendor/backbone/0.9.1/backbone-min.js
  118. +1,290 −0 vendor/backbone/0.9.1/backbone.js
  119. +85 −0 vendor/jasmine/1.1.0/jasmine-bootstrap.css
  120. +190 −0 vendor/jasmine/1.1.0/jasmine-html.js
  121. +288 −0 vendor/jasmine/1.1.0/jasmine-jquery.js
  122. +213 −0 vendor/jasmine/1.1.0/jasmine.bootstrap.js
  123. +2,476 −0 vendor/jasmine/1.1.0/jasmine.js
  124. +4 −0 vendor/jquery/1.7.1/jquery.min.js
  125. +2,470 −0 vendor/twitter/bootstrap.css
  126. +31 −0 vendor/underscore/1.3.1/underscore-min.js
View
1 backbone-eventbroker-min.js
@@ -0,0 +1 @@
+(function(a,b){b.EventBroker=b.EventBroker||function(){var c={},d=function(a,b,c,d){!b&&a.interests&&(b=a,a=a.interests);for(var e in a)c[d](e,b[a[e]],b);return c},e={register:function(a,b){return a||b?d(a,b,this,"on"):this},unregister:function(a,b){return a||b?d(a,b,this,"off"):this}};return a.extend({namespace:"",get:function(d){return c[d]===undefined&&(c[d]=a.extend({namespace:d},b.Events,e)),c[d]},has:function(a){return c[a]!==undefined},destroy:function(a){if(!a)for(a in c)this.destroy(a);else c[a]&&(c[a].off(),delete c[a]);return this}},b.Events,e)}()})(_,Backbone)
View
36 build/build.js
@@ -0,0 +1,36 @@
+
+var parser = require( 'uglify-js' ).parser,
+ uglify = require( 'uglify-js' ).uglify,
+ fs = require( 'fs' ),
+ src = '../src/backbone-eventbroker.js',
+ built = '../backbone-eventbroker-min.js';
+
+var _build = function()
+{
+ console.log( 'Loading ' + src );
+
+ fs.readFile( src, 'utf8', function ( error, data )
+ {
+ if ( error ) {
+ return console.log( 'Error' + error );
+ }
+ _write( _minify( data ) );
+ });
+};
+
+var _minify = function( source )
+{
+ var ast = uglify.ast_squeeze( uglify.ast_mangle( parser.parse( source ) ) );
+ return uglify.gen_code( ast );
+};
+
+var _write = function( min )
+{
+ fs.writeFile( built, min, function( error ) {
+ if ( error ) {
+ return console.log( 'Error' + error );
+ }
+ console.log( 'Minified ' + built + '\nDone' );
+ });
+};
+_build();
View
332 build/node_modules/.bin/uglifyjs
@@ -0,0 +1,332 @@
+#!/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
+ consolidator = uglify.consolidator,
+ jsp = uglify.parser,
+ pro = uglify.uglify;
+
+var options = {
+ ast: false,
+ consolidate: false,
+ mangle: true,
+ mangle_toplevel: false,
+ no_mangle_functions: 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: { },
+ lift_vars: false,
+ 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 "-c":
+ case "--consolidate-primitive-values":
+ options.consolidate = 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 "-nmf":
+ case "--no-mangle-functions":
+ options.no_mangle_functions = 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 "--lift-vars":
+ options.lift_vars = true;
+ 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.replace(/;*$/, ";"));
+ 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.consolidate) ast = time_it("consolidate", function(){
+ return consolidator.ast_consolidate(ast);
+ });
+ if (options.lift_vars) {
+ ast = time_it("lift", function(){ return pro.ast_lift_variables(ast); });
+ }
+ if (options.mangle) ast = time_it("mangle", function(){
+ return pro.ast_mangle(ast, {
+ toplevel : options.mangle_toplevel,
+ defines : options.defines,
+ except : options.reserved_names,
+ no_functions : options.no_mangle_functions
+ });
+ });
+ 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));
+ process.exit(1);
+ }
+};
+
+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."); }
+};
View
4 build/node_modules/uglify-js/.npmignore
@@ -0,0 +1,4 @@
+.DS_Store
+.tmp*~
+*.local.*
+.pinf-*
View
981 build/node_modules/uglify-js/README.html
@@ -0,0 +1,981 @@
+<?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 &ndash; 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-12-09 14:59:08 EET"/>
+<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; }
+ .right {margin-left:auto; margin-right:0px; text-align:right;}
+ .left {margin-left:0px; margin-right:auto; text-align:left;}
+ .center {margin-left:auto; margin-right:auto; text-align:center;}
+ 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; }
+ th.right { text-align:center; }
+ th.left { text-align:center; }
+ th.center { text-align:center; }
+ td.right { text-align:right; }
+ td.left { text-align:left; }
+ td.center { text-align:center; }
+ dt { font-weight: bold; }
+ div.figure { padding: 0.5em; }
+ div.figure p { text-align: center; }
+ div.inlinetask {
+ padding:10px;
+ border:2px solid gray;
+ margin:10px;
+ background: #ffffcc;
+ }
+ 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="preamble">
+
+</div>
+
+<div id="content">
+<h1 class="title">UglifyJS &ndash; 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 &mdash; 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>
+<li><a href="#sec-1-1-2">1.1.2 <code>obj.toString()</code> ==&gt; <code>obj+“”</code> </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 &ndash; no more comments </a></li>
+<li><a href="#sec-1-4-3">1.4.3 Use as a code pre-processor </a></li>
+</ul>
+</li>
+<li><a href="#sec-1-5">1.5 Compression &ndash; 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 &mdash; 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&mdash;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"] ==&gt; foo.bar
+
+</li>
+<li>remove block brackets <code>{}</code>
+
+</li>
+<li>join consecutive var declarations:
+ var a = 10; var b = 20; ==&gt; var a=10,b=20;
+
+</li>
+<li>resolve simple constant expressions: 1 +2 * 3 ==&gt; 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(); ==&gt; foo?bar():baz();
+</li>
+<li>if (!foo) bar(); else baz(); ==&gt; foo?baz():bar();
+</li>
+<li>if (foo) bar(); ==&gt; foo&amp;&amp;bar();
+</li>
+<li>if (!foo) bar(); ==&gt; foo||bar();
+</li>
+<li>if (foo) return bar(); else return baz(); ==&gt; return foo?bar():baz();
+</li>
+<li>if (foo) return bar(); else something(); ==&gt; {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>
+<li>act a limited version of a pre-processor (c.f. the pre-processor of
+ C/C++) to allow you to safely replace selected global symbols with
+ specified values. When combined with the optimisations above this can
+ make UglifyJS operate slightly more like a compilation process, in
+ that when certain symbols are replaced by constant values, entire code
+ blocks may be optimised away as unreachable.
+</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>
+The following transformations can in theory break code, although they're
+probably safe in most practical cases. To enable them you need to pass the
+<code>--unsafe</code> flag.
+</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 class="org-keyword">new</span> <span class="org-type">Array</span>(1, 2, 3, 4) =&gt; [1,2,3,4]
+Array(a, b, c) =&gt; [a,b,c]
+<span class="org-keyword">new</span> <span class="org-type">Array</span>(5) =&gt; Array(5)
+<span class="org-keyword">new</span> <span class="org-type">Array</span>(a) =&gt; 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 class="org-comment-delimiter">// </span><span class="org-comment">case 1. globally declared variable</span>
+ <span class="org-keyword">var</span> <span class="org-variable-name">Array</span>;
+ <span class="org-keyword">new</span> <span class="org-type">Array</span>(1, 2, 3);
+ Array(a, b);
+
+ <span class="org-comment-delimiter">// </span><span class="org-comment">or (can be declared later)</span>
+ <span class="org-keyword">new</span> <span class="org-type">Array</span>(1, 2, 3);
+ <span class="org-keyword">var</span> <span class="org-variable-name">Array</span>;
+
+ <span class="org-comment-delimiter">// </span><span class="org-comment">or (can be a function)</span>
+ <span class="org-keyword">new</span> <span class="org-type">Array</span>(1, 2, 3);
+ <span class="org-keyword">function</span> <span class="org-function-name">Array</span>() { ... }
+
+<span class="org-comment-delimiter">// </span><span class="org-comment">case 2. declared in a function</span>
+ (<span class="org-keyword">function</span>(){
+ a = <span class="org-keyword">new</span> <span class="org-type">Array</span>(1, 2, 3);
+ b = Array(5, 6);
+ <span class="org-keyword">var</span> <span class="org-variable-name">Array</span>;
+ })();
+
+ <span class="org-comment-delimiter">// </span><span class="org-comment">or</span>
+ (<span class="org-keyword">function</span>(<span class="org-variable-name">Array</span>){
+ <span class="org-keyword">return</span> Array(5, 6, 7);
+ })();
+
+ <span class="org-comment-delimiter">// </span><span class="org-comment">or</span>
+ (<span class="org-keyword">function</span>(){
+ <span class="org-keyword">return</span> <span class="org-keyword">new</span> <span class="org-type">Array</span>(1, 2, 3, 4);
+ <span class="org-keyword">function</span> <span class="org-function-name">Array</span>() { ... }
+ })();
+
+ <span class="org-comment-delimiter">// </span><span class="org-comment">etc.</span>
+</pre>
+
+
+</div>
+
+</div>
+
+<div id="outline-container-1-1-2" class="outline-4">
+<h4 id="sec-1-1-2"><span class="section-number-4">1.1.2</span> <code>obj.toString()</code> ==&gt; <code>obj+“”</code> </h4>
+<div class="outline-text-4" id="text-1-1-2">
+
+
+</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 &mdash; <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 class="org-comment-delimiter">## </span><span class="org-comment">clone the repository</span>
+mkdir -p /where/you/wanna/put/it
+<span class="org-builtin">cd</span> /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+<span class="org-comment-delimiter">## </span><span class="org-comment">make the module available to Node</span>
+mkdir -p ~/.node_libraries/
+<span class="org-builtin">cd</span> ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+<span class="org-comment-delimiter">## </span><span class="org-comment">and if you want the CLI script too:</span>
+mkdir -p ~/bin
+<span class="org-builtin">cd</span> ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ <span class="org-comment-delimiter"># </span><span class="org-comment">(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> &mdash; output indented code; when passed, additional
+ options control the beautifier:
+
+<ul>
+<li><code>-i N</code> or <code>--indent N</code> &mdash; indentation level (number of spaces)
+
+</li>
+<li><code>-q</code> or <code>--quote-keys</code> &mdash; quote keys in literal objects (by default,
+ only keys that cannot be identifier names will be quotes).
+
+</li>
+</ul>
+
+</li>
+<li><code>--ascii</code> &mdash; 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> &mdash; don't mangle names.
+
+</li>
+<li><code>-nmf</code> or <code>--no-mangle-functions</code> &ndash; in case you want to mangle variable
+ names, but not touch function names.
+
+</li>
+<li><code>-ns</code> or <code>--no-squeeze</code> &mdash; 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> &mdash; mangle names in the toplevel scope too
+ (by default we don't do this).
+
+</li>
+<li><code>--no-seqs</code> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; output some notes on STDERR (for now just how long
+ each operation takes).
+
+</li>
+<li><code>-d SYMBOL[=VALUE]</code> or <code>--define SYMBOL[=VALUE]</code> &mdash; will replace
+ all instances of the specified symbol where used as an identifier
+ (except where symbol has properly declared by a var declaration or
+ use as function parameter or similar) with the specified value. This
+ argument may be specified multiple times to define multiple
+ symbols - if no value is specified the symbol will be replaced with
+ the value <code>true</code>, or you can specify a numeric value (such as
+ <code>1024</code>), a quoted string value (such as ="object"= or
+ ='https://github.com'<code>), or the name of another symbol or keyword (such as =null</code> or <code>document</code>).
+ This allows you, for example, to assign meaningful names to key
+ constant values but discard the symbolic names in the uglified
+ version for brevity/efficiency, or when used wth care, allows
+ UglifyJS to operate as a form of <b>conditional compilation</b>
+ whereby defining appropriate values may, by dint of the constant
+ folding and dead code removal features above, remove entire
+ superfluous code blocks (e.g. completely remove instrumentation or
+ trace code for production use).
+ Where string values are being defined, the handling of quotes are
+ likely to be subject to the specifics of your command shell
+ environment, so you may need to experiment with quoting styles
+ depending on your platform, or you may find the option
+ <code>--define-from-module</code> more suitable for use.
+
+</li>
+<li><code>-define-from-module SOMEMODULE</code> &mdash; will load the named module (as
+ per the NodeJS <code>require()</code> function) and iterate all the exported
+ properties of the module defining them as symbol names to be defined
+ (as if by the <code>--define</code> option) per the name of each property
+ (i.e. without the module name prefix) and given the value of the
+ property. This is a much easier way to handle and document groups of
+ symbols to be defined rather than a large number of <code>--define</code>
+ options.
+
+</li>
+<li><code>--unsafe</code> &mdash; enable other additional optimizations that are known to be
+ unsafe in some contrived situations, but could still be generally useful.
+ For now only these:
+
+<ul>
+<li>foo.toString() ==&gt; foo+""
+</li>
+<li>new Array(x,&hellip;) ==&gt; [x,&hellip;]
+</li>
+<li>new Array(x) ==&gt; Array(x)
+
+</li>
+</ul>
+
+</li>
+<li><code>--max-line-len</code> (default 32K characters) &mdash; 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 &ndash;max-line-len 0 to disable this
+ safety feature.
+
+</li>
+<li><code>--reserved-names</code> &mdash; 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 &ndash;reserved-names "require,$super".
+
+</li>
+<li><code>--inline-script</code> &ndash; when you want to include the output literally in an
+ HTML <code>&lt;script&gt;</code> tag you can use this option to prevent <code>&lt;/script</code> from
+ showing up in the output.
+
+</li>
+<li><code>--lift-vars</code> &ndash; when you pass this, UglifyJS will apply the following
+ transformations (see the notes in API, <code>ast_lift_variables</code>):
+
+<ul>
+<li>put all <code>var</code> declarations at the start of the scope
+</li>
+<li>make sure a variable is declared only once
+</li>
+<li>discard unused function arguments
+</li>
+<li>discard unused inner (named) functions
+</li>
+<li>finally, try to merge assignments into that one <code>var</code> declaration, if
+ possible.
+</li>
+</ul>
+
+</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 class="org-keyword">var</span> <span class="org-variable-name">jsp</span> = require(<span class="org-string">"uglify-js"</span>).parser;
+<span class="org-keyword">var</span> <span class="org-variable-name">pro</span> = require(<span class="org-string">"uglify-js"</span>).uglify;
+
+<span class="org-keyword">var</span> <span class="org-variable-name">orig_code</span> = <span class="org-string">"... JS code here"</span>;
+<span class="org-keyword">var</span> <span class="org-variable-name">ast</span> = jsp.parse(orig_code); <span class="org-comment-delimiter">// </span><span class="org-comment">parse code and get the initial AST</span>
+ast = pro.ast_mangle(ast); <span class="org-comment-delimiter">// </span><span class="org-comment">get a new AST with mangled names</span>
+ast = pro.ast_squeeze(ast); <span class="org-comment-delimiter">// </span><span class="org-comment">get an AST with compression optimizations</span>
+<span class="org-keyword">var</span> <span class="org-variable-name">final_code</span> = pro.gen_code(ast); <span class="org-comment-delimiter">// </span><span class="org-comment">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> &ndash; 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_lift_variables(ast)</code> &ndash; merge and move <code>var</code> declarations to the
+ scop of the scope; discard unused function arguments or variables; discard
+ unused (named) inner functions. It also tries to merge assignments
+ following the <code>var</code> declaration into it.
+
+<p>
+ If your code is very hand-optimized concerning <code>var</code> declarations, this
+ lifting variable declarations might actually increase size. For me it
+ helps out. On jQuery it adds 865 bytes (243 after gzip). YMMV. Also
+ note that (since it's not enabled by default) this operation isn't yet
+ heavily tested (please report if you find issues!).
+</p>
+<p>
+ Note that although it might increase the image size (on jQuery it gains
+ 865 bytes, 243 after gzip) it's technically more correct: in certain
+ situations, dead code removal might drop variable declarations, which
+ would not happen if the variables are lifted in advance.
+</p>
+<p>
+ Here's an example of what it does:
+</p></li>
+</ul>
+
+
+
+
+
+<pre class="src src-js"><span class="org-keyword">function</span> <span class="org-function-name">f</span>(<span class="org-variable-name">a</span>, <span class="org-variable-name">b</span>, <span class="org-variable-name">c</span>, <span class="org-variable-name">d</span>, <span class="org-variable-name">e</span>) {
+ <span class="org-keyword">var</span> <span class="org-variable-name">q</span>;
+ <span class="org-keyword">var</span> <span class="org-variable-name">w</span>;
+ w = 10;
+ q = 20;
+ <span class="org-keyword">for</span> (<span class="org-keyword">var</span> <span class="org-variable-name">i</span> = 1; i &lt; 10; ++i) {
+ <span class="org-keyword">var</span> <span class="org-variable-name">boo</span> = foo(a);
+ }
+ <span class="org-keyword">for</span> (<span class="org-keyword">var</span> <span class="org-variable-name">i</span> = 0; i &lt; 1; ++i) {
+ <span class="org-keyword">var</span> <span class="org-variable-name">boo</span> = bar(c);
+ }
+ <span class="org-keyword">function</span> <span class="org-function-name">foo</span>(){ ... }
+ <span class="org-keyword">function</span> <span class="org-function-name">bar</span>(){ ... }
+ <span class="org-keyword">function</span> <span class="org-function-name">baz</span>(){ ... }
+}
+
+<span class="org-comment-delimiter">// </span><span class="org-comment">transforms into ==&gt;</span>
+
+<span class="org-keyword">function</span> <span class="org-function-name">f</span>(<span class="org-variable-name">a</span>, <span class="org-variable-name">b</span>, <span class="org-variable-name">c</span>) {
+ <span class="org-keyword">var</span> <span class="org-variable-name">i</span>, <span class="org-variable-name">boo</span>, <span class="org-variable-name">w</span> = 10, <span class="org-variable-name">q</span> = 20;
+ <span class="org-keyword">for</span> (i = 1; i &lt; 10; ++i) {
+ boo = foo(a);
+ }
+ <span class="org-keyword">for</span> (i = 0; i &lt; 1; ++i) {
+ boo = bar(c);
+ }
+ <span class="org-keyword">function</span> <span class="org-function-name">foo</span>() { ... }
+ <span class="org-keyword">function</span> <span class="org-function-name">bar</span>() { ... }
+}
+</pre>
+
+
+<ul>
+<li><code>pro.ast_mangle(ast, options)</code> &ndash; generates a new AST containing mangled
+ (compressed) variable and function names. It supports the following
+ options:
+
+<ul>
+<li><code>toplevel</code> &ndash; mangle toplevel names (by default we don't touch them).
+</li>
+<li><code>except</code> &ndash; an array of names to exclude from compression.
+</li>
+<li><code>defines</code> &ndash; an object with properties named after symbols to
+ replace (see the <code>--define</code> option for the script) and the values
+ representing the AST replacement value.
+
+</li>
+</ul>
+
+</li>
+<li><code>pro.ast_squeeze(ast, options)</code> &ndash; 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> &ndash; 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> &ndash; 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>) &ndash; 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> &ndash; 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>) &ndash; wether
+ to put a space before the colon in object literals
+</li>
+<li><code>ascii_only: false</code> &ndash; pass <code>true</code> if you want to encode non-ASCII
+ characters as <code>\uXXXX</code>.
+</li>
+<li><code>inline_script: false</code> &ndash; pass <code>true</code> to escape occurrences of
+ <code>&lt;/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 &ndash; 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 &mdash; 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 id="outline-container-1-4-3" class="outline-4">
+<h4 id="sec-1-4-3"><span class="section-number-4">1.4.3</span> Use as a code pre-processor </h4>
+<div class="outline-text-4" id="text-1-4-3">
+
+
+<p>
+The <code>--define</code> option can be used, particularly when combined with the
+constant folding logic, as a form of pre-processor to enable or remove
+particular constructions, such as might be used for instrumenting
+development code, or to produce variations aimed at a specific
+platform.
+</p>
+<p>
+The code below illustrates the way this can be done, and how the
+symbol replacement is performed.
+</p>
+
+
+
+<pre class="src src-js">CLAUSE1: <span class="org-keyword">if</span> (<span class="org-keyword">typeof</span> DEVMODE === <span class="org-string">'undefined'</span>) {
+ DEVMODE = <span class="org-constant">true</span>;
+}
+
+<span class="org-function-name">CLAUSE2</span>: <span class="org-keyword">function</span> init() {
+ <span class="org-keyword">if</span> (DEVMODE) {
+ console.log(<span class="org-string">"init() called"</span>);
+ }
+ ....
+ DEVMODE &amp;amp;&amp;amp; console.log(<span class="org-string">"init() complete"</span>);
+}
+
+<span class="org-function-name">CLAUSE3</span>: <span class="org-keyword">function</span> reportDeviceStatus(<span class="org-variable-name">device</span>) {
+ <span class="org-keyword">var</span> <span class="org-variable-name">DEVMODE</span> = device.mode, <span class="org-variable-name">DEVNAME</span> = device.name;
+ <span class="org-keyword">if</span> (DEVMODE === <span class="org-string">'open'</span>) {
+ ....
+ }
+}
+</pre>
+
+
+<p>
+When the above code is normally executed, the undeclared global
+variable <code>DEVMODE</code> will be assigned the value <b>true</b> (see <code>CLAUSE1</code>)
+and so the <code>init()</code> function (<code>CLAUSE2</code>) will write messages to the
+console log when executed, but in <code>CLAUSE3</code> a locally declared
+variable will mask access to the <code>DEVMODE</code> global symbol.
+</p>
+<p>
+If the above code is processed by UglifyJS with an argument of
+<code>--define DEVMODE=false</code> then UglifyJS will replace <code>DEVMODE</code> with the
+boolean constant value <b>false</b> within <code>CLAUSE1</code> and <code>CLAUSE2</code>, but it
+will leave <code>CLAUSE3</code> as it stands because there <code>DEVMODE</code> resolves to
+a validly declared variable.
+</p>
+<p>
+And more so, the constant-folding features of UglifyJS will recognise
+that the <code>if</code> condition of <code>CLAUSE1</code> is thus always false, and so will
+remove the test and body of <code>CLAUSE1</code> altogether (including the
+otherwise slightly problematical statement <code>false = true;</code> which it
+will have formed by replacing <code>DEVMODE</code> in the body). Similarly,
+within <code>CLAUSE2</code> both calls to <code>console.log()</code> will be removed
+altogether.
+</p>
+<p>
+In this way you can mimic, to a limited degree, the functionality of
+the C/C++ pre-processor to enable or completely remove blocks
+depending on how certain symbols are defined - perhaps using UglifyJS
+to generate different versions of source aimed at different
+environments
+</p>
+<p>
+It is recommmended (but not made mandatory) that symbols designed for
+this purpose are given names consisting of <code>UPPER_CASE_LETTERS</code> to
+distinguish them from other (normal) symbols and avoid the sort of
+clash that <code>CLAUSE3</code> above illustrates.
+</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 &ndash; how good is it? </h3>
+<div class="outline-text-3" id="text-1-5">
+
+
+<p>
+Here are updated statistics. (I also updated my Google Closure and YUI
+installations).
+</p>
+<p>
+We're still a lot better than YUI in terms of compression, though slightly
+slower. We're still a lot faster than Closure, and compression after gzip
+is comparable.
+</p>
+<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
+<caption></caption>
+<colgroup><col class="left" /><col class="left" /><col class="right" /><col class="left" /><col class="right" /><col class="left" /><col class="right" />
+</colgroup>
+<thead>
+<tr><th scope="col" class="left">File</th><th scope="col" class="left">UglifyJS</th><th scope="col" class="right">UglifyJS+gzip</th><th scope="col" class="left">Closure</th><th scope="col" class="right">Closure+gzip</th><th scope="col" class="left">YUI</th><th scope="col" class="right">YUI+gzip</th></tr>
+</thead>
+<tbody>
+<tr><td class="left">jquery-1.6.2.js</td><td class="left">91001 (0:01.59)</td><td class="right">31896</td><td class="left">90678 (0:07.40)</td><td class="right">31979</td><td class="left">101527 (0:01.82)</td><td class="right">34646</td></tr>
+<tr><td class="left">paper.js</td><td class="left">142023 (0:01.65)</td><td class="right">43334</td><td class="left">134301 (0:07.42)</td><td class="right">42495</td><td class="left">173383 (0:01.58)</td><td class="right">48785</td></tr>
+<tr><td class="left">prototype.js</td><td class="left">88544 (0:01.09)</td><td class="right">26680</td><td class="left">86955 (0:06.97)</td><td class="right">26326</td><td class="left">92130 (0:00.79)</td><td class="right">28624</td></tr>
+<tr><td class="left">thelib-full.js (DynarchLIB)</td><td class="left">251939 (0:02.55)</td><td class="right">72535</td><td class="left">249911 (0:09.05)</td><td class="right">72696</td><td class="left">258869 (0:01.94)</td><td class="right">76584</td></tr>
+</tbody>
+</table>
+
+
+</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>Twitter: <a href="http://twitter.com/UglifyJS">@UglifyJS</a>
+</li>
+<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 &lt;mihai.bazon@gmail.com&gt;
+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 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>
+
+</div>
+</div>
+</div>
+
+<div id="postamble">
+<p class="date">Date: 2011-12-09 14:59:08 EET</p>
+<p class="author">Author: Mihai Bazon</p>
+<p class="creator">Org version 7.7 with Emacs version 23</p>
+<a href="http://validator.w3.org/check?uri=referer">Validate XHTML 1.0</a>
+
+</div>
+</body>
+</html>
View
578 build/node_modules/uglify-js/README.org
@@ -0,0 +1,578 @@
+#+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).
+
+ - act a limited version of a pre-processor (c.f. the pre-processor of
+ C/C++) to allow you to safely replace selected global symbols with
+ specified values. When combined with the optimisations above this can
+ make UglifyJS operate slightly more like a compilation process, in
+ that when certain symbols are replaced by constant values, entire code
+ blocks may be optimised away as unreachable.
+
+** <<Unsafe transformations>>
+
+The following transformations can in theory break code, although they're
+probably safe in most practical cases. To enable them you need to pass the
+=--unsafe= flag.
+
+*** 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
+
+*** =obj.toString()= ==> =obj+“”=
+
+** 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).
+
+- =-c= or =----consolidate-primitive-values= --- consolidates null, Boolean,
+ and String values. Known as aliasing in the Closure Compiler. Worsens the
+ data compression ratio of gzip.
+
+- =--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 names.
+
+- =-nmf= or =--no-mangle-functions= -- in case you want to mangle variable
+ names, but not touch function 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).
+
+- =-d SYMBOL[=VALUE]= or =--define SYMBOL[=VALUE]= --- will replace
+ all instances of the specified symbol where used as an identifier
+ (except where symbol has properly declared by a var declaration or
+ use as function parameter or similar) with the specified value. This
+ argument may be specified multiple times to define multiple
+ symbols - if no value is specified the symbol will be replaced with
+ the value =true=, or you can specify a numeric value (such as
+ =1024=), a quoted string value (such as ="object"= or
+ ='https://github.com'=), or the name of another symbol or keyword
+ (such as =null= or =document=).
+ This allows you, for example, to assign meaningful names to key
+ constant values but discard the symbolic names in the uglified
+ version for brevity/efficiency, or when used wth care, allows
+ UglifyJS to operate as a form of *conditional compilation*
+ whereby defining appropriate values may, by dint of the constant
+ folding and dead code removal features above, remove entire
+ superfluous code blocks (e.g. completely remove instrumentation or
+ trace code for production use).
+ Where string values are being defined, the handling of quotes are
+ likely to be subject to the specifics of your command shell
+ environment, so you may need to experiment with quoting styles
+ depending on your platform, or you may find the option
+ =--define-from-module= more suitable for use.
+
+- =-define-from-module SOMEMODULE= --- will load the named module (as
+ per the NodeJS =require()= function) and iterate all the exported
+ properties of the module defining them as symbol names to be defined
+ (as if by the =--define= option) per the name of each property
+ (i.e. without the module name prefix) and given the value of the
+ property. This is a much easier way to handle and document groups of
+ symbols to be defined rather than a large number of =--define=
+ options.
+
+- =--unsafe= --- enable other additional optimizations that are known to be
+ unsafe in some contrived situations, but could still be generally useful.
+ For now only these:
+
+ - foo.toString() ==> foo+""
+ - new Array(x,...) ==> [x,...]
+ - new Array(x) ==> Array(x)
+
+- =--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.
+
+- =--lift-vars= -- when you pass this, UglifyJS will apply the following
+ transformations (see the notes in API, =ast_lift_variables=):
+
+ - put all =var= declarations at the start of the scope
+ - make sure a variable is declared only once
+ - discard unused function arguments
+ - discard unused inner (named) functions
+ - finally, try to merge assignments into that one =var= declaration, if
+ possible.
+
+*** 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_lift_variables(ast)= -- merge and move =var= declarations to the
+ scop of the scope; discard unused function arguments or variables; discard
+ unused (named) inner functions. It also tries to merge assignments
+ following the =var= declaration into it.
+
+ If your code is very hand-optimized concerning =var= declarations, this
+ lifting variable declarations might actually increase size. For me it
+ helps out. On jQuery it adds 865 bytes (243 after gzip). YMMV. Also
+ note that (since it's not enabled by default) this operation isn't yet
+ heavily tested (please report if you find issues!).
+
+ Note that although it might increase the image size (on jQuery it gains
+ 865 bytes, 243 after gzip) it's technically more correct: in certain
+ situations, dead code removal might drop variable declarations, which
+ would not happen if the variables are lifted in advance.
+
+ Here's an example of what it does:
+
+#+BEGIN_SRC js
+function f(a, b, c, d, e) {
+ var q;
+ var w;
+ w = 10;
+ q = 20;
+ for (var i = 1; i < 10; ++i) {
+ var boo = foo(a);
+ }
+ for (var i = 0; i < 1; ++i) {
+ var boo = bar(c);
+ }
+ function foo(){ ... }
+ function bar(){ ... }
+ function baz(){ ... }
+}
+
+// transforms into ==>
+
+function f(a, b, c) {
+ var i, boo, w = 10, q = 20;
+ for (i = 1; i < 10; ++i) {
+ boo = foo(a);
+ }
+ for (i = 0; i < 1; ++i) {
+ boo = bar(c);
+ }
+ function foo() { ... }
+ function bar() { ... }
+}
+#+END_SRC
+
+- =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.
+ - =defines= -- an object with properties named after symbols to
+ replace (see the =--define= option for the script) and the values
+ representing the AST replacement value.
+
+- =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.
+
+*** Use as a code pre-processor
+
+The =--define= option can be used, particularly when combined with the
+constant folding logic, as a form of pre-processor to enable or remove
+particular constructions, such as might be used for instrumenting
+development code, or to produce variations aimed at a specific
+platform.
+
+The code below illustrates the way this can be done, and how the
+symbol replacement is performed.
+
+#+BEGIN_SRC js
+CLAUSE1: if (typeof DEVMODE === 'undefined') {
+ DEVMODE = true;
+}
+
+CLAUSE2: function init() {
+ if (DEVMODE) {
+ console.log("init() called");
+ }
+ ....
+ DEVMODE &amp;&amp; console.log("init() complete");
+}
+
+CLAUSE3: function reportDeviceStatus(device) {
+ var DEVMODE = device.mode, DEVNAME = device.name;
+ if (DEVMODE === 'open') {
+ ....
+ }
+}
+#+END_SRC
+
+When the above code is normally executed, the undeclared global
+variable =DEVMODE= will be assigned the value *true* (see =CLAUSE1=)
+and so the =init()= function (=CLAUSE2=) will write messages to the
+console log when executed, but in =CLAUSE3= a locally declared
+variable will mask access to the =DEVMODE= global symbol.
+
+If the above code is processed by UglifyJS with an argument of
+=--define DEVMODE=false= then UglifyJS will replace =DEVMODE= with the
+boolean constant value *false* within =CLAUSE1= and =CLAUSE2=, but it
+will leave =CLAUSE3= as it stands because there =DEVMODE= resolves to
+a validly declared variable.
+
+And more so, the constant-folding features of UglifyJS will recognise
+that the =if= condition of =CLAUSE1= is thus always false, and so will
+remove the test and body of =CLAUSE1= altogether (including the
+otherwise slightly problematical statement =false = true;= which it
+will have formed by replacing =DEVMODE= in the body). Similarly,
+within =CLAUSE2= both calls to =console.log()= will be removed
+altogether.
+
+In this way you can mimic, to a limited degree, the functionality of
+the C/C++ pre-processor to enable or completely remove blocks
+depending on how certain symbols are defined - perhaps using UglifyJS
+to generate different versions of source aimed at different
+environments
+
+It is recommmended (but not made mandatory) that symbols designed for
+this purpose are given names consisting of =UPPER_CASE_LETTERS= to
+distinguish them from other (normal) symbols and avoid the sort of
+clash that =CLAUSE3= above illustrates.
+
+** Compression -- how good is it?
+
+Here are updated statistics. (I also updated my Google Closure and YUI
+installations).
+
+We're still a lot better than YUI in terms of compression, though slightly
+slower. We're still a lot faster than Closure, and compression after gzip
+is comparable.
+
+| File | UglifyJS | UglifyJS+gzip | Closure | Closure+gzip | YUI | YUI+gzip |
+|-----------------------------+------------------+---------------+------------------+--------------+------------------+----------|
+| jquery-1.6.2.js | 91001 (0:01.59) | 31896 | 90678 (0:07.40) | 31979 | 101527 (0:01.82) | 34646 |
+| paper.js | 142023 (0:01.65) | 43334 | 134301 (0:07.42) | 42495 | 173383 (0:01.58) | 48785 |
+| prototype.js | 88544 (0:01.09) | 26680 | 86955 (0:06.97) | 26326 | 92130 (0:00.79) | 28624 |
+| thelib-full.js (DynarchLIB) | 251939 (0:02.55) | 72535 | 249911 (0:09.05) | 72696 | 258869 (0:01.94) | 76584 |
+
+** 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
+
+- Twitter: [[http://twitter.com/UglifyJS][@UglifyJS]]
+- 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
View
332 build/node_modules/uglify-js/bin/uglifyjs
@@ -0,0 +1,332 @@
+#!/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
+ consolidator = uglify.consolidator,
+ jsp = uglify.parser,
+ pro = uglify.uglify;
+
+var options = {
+ ast: false,
+ consolidate: false,
+ mangle: true,
+ mangle_toplevel: false,
+ no_mangle_functions: 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: { },
+ lift_vars: false,
+ 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 "-c":
+ case "--consolidate-primitive-values":
+ options.consolidate = 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 "-nmf":
+ case "--no-mangle-functions":
+ options.no_mangle_functions = 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;