dot.dot.dot.exampol

node_modules/uglify-js/.npmignore

@@ -0,0 +1,4 @@
+.DS_Store
+.tmp*~
+*.local.*
+.pinf-*

node_modules/uglify-js/README.org

@@ -0,0 +1,571 @@
+#+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).
+
+- =--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).
+
+- =-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

node_modules/uglify-js/bin/uglifyjs

@@ -0,0 +1,317 @@
+#! /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: { },
+        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 "-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 "--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 + ";");
+        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.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
+                        });
+                });
+                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."); }
+};

node_modules/uglify-js/docstyle.css

@@ -0,0 +1,75 @@
+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; }
+}

node_modules/uglify-js/lib/object-ast.js

@@ -0,0 +1,75 @@
+var jsp = require("./parse-js"),
+    pro = require("./process");
+
+var BY_TYPE = {};
+
+function HOP(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+function AST_Node(parent) {
+        this.parent = parent;
+};
+
+AST_Node.prototype.init = function(){};
+
+function DEFINE_NODE_CLASS(type, props, methods) {
+        var base = methods && methods.BASE || AST_Node;
+        if (!base) base = AST_Node;
+        function D(parent, data) {
+                base.apply(this, arguments);
+                if (props) props.forEach(function(name, i){
+                        this["_" + name] = data[i];
+                });
+                this.init();
+        };
+        var P = D.prototype = new AST_Node;
+        P.node_type = function(){ return type };
+        if (props) props.forEach(function(name){
+                var propname = "_" + name;
+                P["set_" + name] = function(val) {
+                        this[propname] = val;
+                        return this;
+                };
+                P["get_" + name] = function() {
+                        return this[propname];
+                };
+        });
+        if (type != null) BY_TYPE[type] = D;
+        if (methods) for (var i in methods) if (HOP(methods, i)) {
+                P[i] = methods[i];
+        }
+        return D;
+};
+
+var AST_String_Node = DEFINE_NODE_CLASS("string", ["value"]);
+var AST_Number_Node = DEFINE_NODE_CLASS("num", ["value"]);
+var AST_Name_Node = DEFINE_NODE_CLASS("name", ["value"]);
+
+var AST_Statlist_Node = DEFINE_NODE_CLASS(null, ["body"]);
+var AST_Root_Node = DEFINE_NODE_CLASS("toplevel", null, { BASE: AST_Statlist_Node });
+var AST_Block_Node = DEFINE_NODE_CLASS("block", null, { BASE: AST_Statlist_Node });
+var AST_Splice_Node = DEFINE_NODE_CLASS("splice", null, { BASE: AST_Statlist_Node });
+
+var AST_Var_Node = DEFINE_NODE_CLASS("var", ["definitions"]);
+var AST_Const_Node = DEFINE_NODE_CLASS("const", ["definitions"]);
+
+var AST_Try_Node = DEFINE_NODE_CLASS("try", ["body", "catch", "finally"]);
+var AST_Throw_Node = DEFINE_NODE_CLASS("throw", ["exception"]);
+
+var AST_New_Node = DEFINE_NODE_CLASS("new", ["constructor", "arguments"]);
+
+var AST_Switch_Node = DEFINE_NODE_CLASS("switch", ["expression", "branches"]);
+var AST_Switch_Branch_Node = DEFINE_NODE_CLASS(null, ["expression", "body"]);
+
+var AST_Break_Node = DEFINE_NODE_CLASS("break", ["label"]);
+var AST_Continue_Node = DEFINE_NODE_CLASS("continue", ["label"]);
+var AST_Assign_Node = DEFINE_NODE_CLASS("assign", ["operator", "lvalue", "rvalue"]);
+var AST_Dot_Node = DEFINE_NODE_CLASS("dot", ["expression", "name"]);
+var AST_Call_Node = DEFINE_NODE_CLASS("call", ["function", "arguments"]);
+
+var AST_Lambda_Node = DEFINE_NODE_CLASS(null, ["name", "arguments", "body"])
+var AST_Function_Node = DEFINE_NODE_CLASS("function", null, AST_Lambda_Node);
+var AST_Defun_Node = DEFINE_NODE_CLASS("defun", null, AST_Lambda_Node);
+
+var AST_If_Node = DEFINE_NODE_CLASS("if", ["condition", "then", "else"]);

node_modules/uglify-js/lib/squeeze-more.js

@@ -0,0 +1,51 @@
+var jsp = require("./parse-js"),
+    pro = require("./process"),
+    slice = jsp.slice,
+    member = jsp.member,
+    curry = jsp.curry,
+    MAP = pro.MAP,
+    PRECEDENCE = jsp.PRECEDENCE,
+    OPERATORS = jsp.OPERATORS;
+
+function ast_squeeze_more(ast) {
+        var w = pro.ast_walker(), walk = w.walk, scope;
+        function with_scope(s, cont) {
+                var save = scope, ret;
+                scope = s;
+                ret = cont();
+                scope = save;
+                return ret;
+        };
+        function _lambda(name, args, body) {
+                return [ this[0], name, args, with_scope(body.scope, curry(MAP, body, walk)) ];
+        };
+        return w.with_walkers({
+                "toplevel": function(body) {
+                        return [ this[0], with_scope(this.scope, curry(MAP, body, walk)) ];
+                },
+                "function": _lambda,
+                "defun": _lambda,
+                "new": function(ctor, args) {
+                        if (ctor[0] == "name" && ctor[1] == "Array" && !scope.has("Array")) {
+                                if (args.length != 1) {
+                                        return [ "array", args ];
+                                } else {
+                                        return walk([ "call", [ "name", "Array" ], args ]);
+                                }
+                        }
+                },
+                "call": function(expr, args) {
+                        if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+                                // foo.toString()  ==>  foo+""
+                                return [ "binary", "+", expr[1], [ "string", "" ]];
+                        }
+                        if (expr[0] == "name" && expr[1] == "Array" && args.length != 1 && !scope.has("Array")) {
+                                return [ "array", args ];
+                        }
+                }
+        }, function() {
+                return walk(pro.ast_add_scope(ast));
+        });
+};
+
+exports.ast_squeeze_more = ast_squeeze_more;

node_modules/uglify-js/package.json

@@ -0,0 +1,24 @@
+{
+        "name"    : "uglify-js",
+
+        "description" : "JavaScript parser and compressor/beautifier toolkit",
+
+        "author"  : {
+                "name"  : "Mihai Bazon",
+                "email" : "mihai.bazon@gmail.com",
+                "url"   : "http://mihai.bazon.net/blog"
+        },
+
+        "version" : "1.1.1",
+
+        "main"    : "./uglify-js.js",
+
+        "bin"     : {
+                "uglifyjs" : "./bin/uglifyjs"
+        },
+
+        "repository": {
+                "type": "git",
+                "url": "git@github.com:mishoo/UglifyJS.git"
+        }
+}

node_modules/uglify-js/package.json~

@@ -0,0 +1,24 @@
+{
+        "name"    : "uglify-js",
+
+        "description" : "JavaScript parser and compressor/beautifier toolkit",
+
+        "author"  : {
+                "name"  : "Mihai Bazon",
+                "email" : "mihai.bazon@gmail.com",
+                "url"   : "http://mihai.bazon.net/blog"
+        },
+
+        "version" : "1.1.0",
+
+        "main"    : "./uglify-js.js",
+
+        "bin"     : {
+                "uglifyjs" : "./bin/uglifyjs"
+        },
+
+        "repository": {
+                "type": "git",
+                "url": "git@github.com:mishoo/UglifyJS.git"
+        }
+}

node_modules/uglify-js/test/beautify.js

@@ -0,0 +1,28 @@
+#! /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."); }
+};

node_modules/uglify-js/test/testparser.js

@@ -0,0 +1,403 @@
+#! /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<6F>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'],
+                ['if (true) /=a/.test("a");', 'regexp starting with "=" in not obvious context (not implied by preceding token)']
+	];
+
+	for (var i=0; i<inps.length; ++i) {
+		callback(i, inps[i][0], inps[i][1]);
+	};
+};

node_modules/uglify-js/test/unit/compress/expected/array1.js

@@ -0,0 +1 @@
+[],Array(1),[1,2,3]

node_modules/uglify-js/test/unit/compress/expected/array2.js

@@ -0,0 +1 @@
+(function(){var a=function(){};return new a(1,2,3,4)})()

node_modules/uglify-js/test/unit/compress/expected/array3.js

@@ -0,0 +1 @@
+(function(){function a(){}return new a(1,2,3,4)})()

node_modules/uglify-js/test/unit/compress/expected/array4.js

@@ -0,0 +1 @@
+(function(){function a(){}(function(){return new a(1,2,3)})()})()

node_modules/uglify-js/test/unit/compress/expected/assignment.js

@@ -0,0 +1 @@
+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

node_modules/uglify-js/test/unit/compress/expected/concatstring.js

@@ -0,0 +1 @@
+var a=a+"a"+"b"+1+c,b=a+"c"+"ds"+123+c,c=a+"c"+123+d+"ds"+c

node_modules/uglify-js/test/unit/compress/expected/const.js

@@ -0,0 +1 @@
+var a=13,b=1/3

node_modules/uglify-js/test/unit/compress/expected/empty-blocks.js

@@ -0,0 +1 @@
+function bar(){return--x}function foo(){while(bar());}function mak(){for(;;);}var x=5

node_modules/uglify-js/test/unit/compress/expected/forstatement.js

@@ -0,0 +1 @@
+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)

node_modules/uglify-js/test/unit/compress/expected/if.js

@@ -0,0 +1 @@
+var a=1;a==1?a=2:a=17

node_modules/uglify-js/test/unit/compress/expected/ifreturn.js

@@ -0,0 +1 @@
+function a(a){return a==1?2:17}

node_modules/uglify-js/test/unit/compress/expected/ifreturn2.js

@@ -0,0 +1 @@
+function x(a){return typeof a=="object"?a:a===42?0:a*2}function y(a){return typeof a=="object"?a:null}

node_modules/uglify-js/test/unit/compress/expected/issue10.js

@@ -0,0 +1 @@
+function f(){var a;return(a="a")?a:a}f()

node_modules/uglify-js/test/unit/compress/expected/issue11.js

@@ -0,0 +1 @@
+new(A,B),new(A||B),new(X?A:B)

node_modules/uglify-js/test/unit/compress/expected/issue13.js

@@ -0,0 +1 @@
+var a=/^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#])(?::(\d))?)?(..?$|(?:[^?#\/]\/))([^?#]*)(?:\?([^#]))?(?:#(.))?/

node_modules/uglify-js/test/unit/compress/expected/issue14.js

@@ -0,0 +1 @@
+var a={"\b":"\\b","\t":"\\t","\n":"\\n","\f":"\\f","\r":"\\r",'"':'\\"',"\\":"\\\\"}

node_modules/uglify-js/test/unit/compress/expected/issue16.js

@@ -0,0 +1 @@
+var a=3250441966

node_modules/uglify-js/test/unit/compress/expected/issue17.js

@@ -0,0 +1 @@
+var a=function(b){b(),a()}

node_modules/uglify-js/test/unit/compress/expected/issue20.js

@@ -0,0 +1 @@
+a:1

node_modules/uglify-js/test/unit/compress/expected/issue21.js

@@ -0,0 +1 @@
+var a=0;switch(a){case 0:a++}

node_modules/uglify-js/test/unit/compress/expected/issue25.js

@@ -0,0 +1 @@
+label1:{label2:break label2;console.log(1)}

node_modules/uglify-js/test/unit/compress/expected/issue27.js

@@ -0,0 +1 @@
+(a?b:c)?d:e

node_modules/uglify-js/test/unit/compress/expected/issue28.js

@@ -0,0 +1 @@
+o={".5":.5},o={.5:.5},o={.5:.5}

node_modules/uglify-js/test/unit/compress/expected/issue29.js

@@ -0,0 +1 @@
+result=function(){return 1}()

node_modules/uglify-js/test/unit/compress/expected/issue30.js

@@ -0,0 +1 @@
+var a=8,b=4,c=4

node_modules/uglify-js/test/unit/compress/expected/issue34.js

@@ -0,0 +1 @@
+var a={};a["this"]=1,a.that=2

node_modules/uglify-js/test/unit/compress/expected/issue4.js

@@ -0,0 +1 @@
+var a=2e3,b=.002,c=2e-5

node_modules/uglify-js/test/unit/compress/expected/issue48.js

@@ -0,0 +1 @@
+var s,i;s="",i=0

node_modules/uglify-js/test/unit/compress/expected/issue50.js

@@ -0,0 +1 @@
+function bar(a){try{foo()}catch(b){alert("Exception caught (foo not defined)")}alert(a)}bar(10)

node_modules/uglify-js/test/unit/compress/expected/issue53.js

@@ -0,0 +1 @@
+x=(y,z)

node_modules/uglify-js/test/unit/compress/expected/issue54.1.js

@@ -0,0 +1 @@
+foo+"",a.toString(16),b.toString.call(c)

node_modules/uglify-js/test/unit/compress/expected/issue68.js

@@ -0,0 +1 @@
+function f(){function b(){}if(a)return;b()}

node_modules/uglify-js/test/unit/compress/expected/issue69.js

@@ -0,0 +1 @@
+[(a,b)]

node_modules/uglify-js/test/unit/compress/expected/issue9.js

@@ -0,0 +1 @@
+var a={a:1,b:2}

node_modules/uglify-js/test/unit/compress/expected/mangle.js

@@ -0,0 +1 @@
+(function(){var a=function b(a,b,c){return b}})()

node_modules/uglify-js/test/unit/compress/expected/null_string.js

@@ -0,0 +1 @@
+var nullString="\0"

node_modules/uglify-js/test/unit/compress/expected/strict-equals.js

@@ -0,0 +1 @@
+typeof a=="string",b+""!=c+"",d<e==f<g

node_modules/uglify-js/test/unit/compress/expected/var.js

@@ -0,0 +1 @@
+var a=1,b=2

node_modules/uglify-js/test/unit/compress/expected/whitespace.js

@@ -0,0 +1 @@
+function id(a){return a}

node_modules/uglify-js/test/unit/compress/expected/with.js

@@ -0,0 +1 @@
+with({});

node_modules/uglify-js/test/unit/compress/test/array1.js

@@ -0,0 +1,3 @@
+new Array();
+new Array(1);
+new Array(1, 2, 3);

node_modules/uglify-js/test/unit/compress/test/array2.js

@@ -0,0 +1,4 @@
+(function(){
+        var Array = function(){};
+        return new Array(1, 2, 3, 4);
+})();

node_modules/uglify-js/test/unit/compress/test/array3.js

@@ -0,0 +1,4 @@
+(function(){
+        return new Array(1, 2, 3, 4);
+        function Array() {};
+})();

node_modules/uglify-js/test/unit/compress/test/array4.js

@@ -0,0 +1,6 @@
+(function(){
+        (function(){
+                return new Array(1, 2, 3);
+        })();
+        function Array(){};
+})();

node_modules/uglify-js/test/unit/compress/test/assignment.js

@@ -0,0 +1,20 @@
+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;

node_modules/uglify-js/test/unit/compress/test/concatstring.js

@@ -0,0 +1,3 @@
+var a = a + "a" + "b" + 1 + c;
+var b = a + "c" + "ds" + 123 + c;
+var c = a + "c" + 123 + d + "ds" + c;

node_modules/uglify-js/test/unit/compress/test/const.js

@@ -0,0 +1,5 @@
+// test that the calculation is fold to 13
+var a = 1 + 2 * 6;
+
+// test that it isn't replaced with 0.3333 because that is more characters
+var b = 1/3;

node_modules/uglify-js/test/unit/compress/test/empty-blocks.js

@@ -0,0 +1,4 @@
+var x = 5;
+function bar() { return --x; }
+function foo() { while (bar()); }
+function mak() { for(;;); }

node_modules/uglify-js/test/unit/compress/test/forstatement.js

@@ -0,0 +1,10 @@
+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); }

node_modules/uglify-js/test/unit/compress/test/if.js

@@ -0,0 +1,6 @@
+var a = 1;
+if (a == 1) {
+	a = 2;
+} else {
+	a = 17;
+}

node_modules/uglify-js/test/unit/compress/test/ifreturn.js

@@ -0,0 +1,9 @@
+function a(b) {
+	if (b == 1) {
+		return 2;
+	} else {
+		return 17;
+	}
+
+	return 3;
+}

node_modules/uglify-js/test/unit/compress/test/ifreturn2.js

@@ -0,0 +1,16 @@
+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;
+};

node_modules/uglify-js/test/unit/compress/test/issue10.js

@@ -0,0 +1 @@
+function f() { var a; if (a = 'a') { return a; } else { return a; } }; f();

node_modules/uglify-js/test/unit/compress/test/issue11.js

@@ -0,0 +1,3 @@
+new (A, B)
+new (A || B)
+new (X ? A : B)

node_modules/uglify-js/test/unit/compress/test/issue13.js

@@ -0,0 +1 @@
+var a = /^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#])(?::(\d))?)?(..?$|(?:[^?#\/]\/))([^?#]*)(?:\?([^#]))?(?:#(.))?/;

node_modules/uglify-js/test/unit/compress/test/issue14.js

@@ -0,0 +1 @@
+var a = {'\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '\\': '\\\\'};

node_modules/uglify-js/test/unit/compress/test/issue16.js

@@ -0,0 +1 @@
+var a = 0xC1BDCEEE;

node_modules/uglify-js/test/unit/compress/test/issue17.js

@@ -0,0 +1,4 @@
+var a = function(b) {
+    b();
+    a()
+}

node_modules/uglify-js/test/unit/compress/test/issue20.js

@@ -0,0 +1 @@
+{a: 1}

node_modules/uglify-js/test/unit/compress/test/issue21.js

@@ -0,0 +1,6 @@
+var a = 0;
+switch(a) {
+    case 0:
+        a++;
+        break;
+}

node_modules/uglify-js/test/unit/compress/test/issue25.js

@@ -0,0 +1,7 @@
+label1 : {
+    label2 : {
+        break label2;
+        console.log(2);
+    }
+    console.log(1);
+}

node_modules/uglify-js/test/unit/compress/test/issue27.js

@@ -0,0 +1 @@
+(a ? b : c) ? d : e

node_modules/uglify-js/test/unit/compress/test/issue28.js

@@ -0,0 +1,3 @@
+o = {'.5':.5}
+o = {'0.5':.5}
+o = {0.5:.5}

node_modules/uglify-js/test/unit/compress/test/issue29.js

@@ -0,0 +1 @@
+result=(function(){ return 1;})()

node_modules/uglify-js/test/unit/compress/test/issue30.js

@@ -0,0 +1,3 @@
+var a = 1 << 3;
+var b = 8 >> 1;
+var c = 8 >>> 1;

node_modules/uglify-js/test/unit/compress/test/issue34.js

@@ -0,0 +1,3 @@
+var a = {};
+a["this"] = 1;
+a["that"] = 2;

node_modules/uglify-js/test/unit/compress/test/issue4.js

@@ -0,0 +1,3 @@
+var a = 2e3;
+var b = 2e-3;
+var c = 2e-5;

node_modules/uglify-js/test/unit/compress/test/issue48.js

@@ -0,0 +1 @@
+var s, i; s = ''; i = 0;

node_modules/uglify-js/test/unit/compress/test/issue50.js

@@ -0,0 +1,9 @@
+function bar(a) {
+        try {
+                foo();
+        } catch(e) {
+                alert("Exception caught (foo not defined)");
+        }
+        alert(a);               // 10 in FF, "[object Error]" in IE
+}
+bar(10);

node_modules/uglify-js/test/unit/compress/test/issue53.js

@@ -0,0 +1 @@
+x = (y, z)

node_modules/uglify-js/test/unit/compress/test/issue54.1.js

@@ -0,0 +1,3 @@
+foo.toString();
+a.toString(16);
+b.toString.call(c);

node_modules/uglify-js/test/unit/compress/test/issue68.js

@@ -0,0 +1,5 @@
+function f() {
+        if (a) return;
+        g();
+        function g(){}
+};

node_modules/uglify-js/test/unit/compress/test/issue69.js

@@ -0,0 +1 @@
+[(a,b)]

node_modules/uglify-js/test/unit/compress/test/issue9.js

@@ -0,0 +1,4 @@
+var a = {
+    a: 1,
+    b: 2, // <-- trailing comma
+};

node_modules/uglify-js/test/unit/compress/test/mangle.js

@@ -0,0 +1,5 @@
+(function() {
+    var x = function fun(a, fun, b) {
+        return fun;
+    };
+}());

node_modules/uglify-js/test/unit/compress/test/null_string.js

@@ -0,0 +1 @@
+var nullString = "\0"

node_modules/uglify-js/test/unit/compress/test/strict-equals.js

@@ -0,0 +1,3 @@
+typeof a === 'string'
+b + "" !== c + ""
+d < e === f < g

node_modules/uglify-js/test/unit/compress/test/var.js

@@ -0,0 +1,3 @@
+// var declarations after each other should be combined
+var a = 1;
+var b = 2;

node_modules/uglify-js/test/unit/compress/test/whitespace.js

@@ -0,0 +1,21 @@
+function id(a) {
+  // Form-Feed
+  // Vertical Tab
+   // No-Break Space
+  ᠎// Mongolian Vowel Separator
+   // En quad
+   // Em quad
+   // En space
+   // Em space
+   // Three-Per-Em Space
+   // Four-Per-Em Space
+   // Six-Per-Em Space
+   // Figure Space
+   // Punctuation Space
+   // Thin Space
+   // Hair Space
+   // Narrow No-Break Space
+   // Medium Mathematical Space
+  　// Ideographic Space
+  return a;
+}

node_modules/uglify-js/test/unit/compress/test/with.js

@@ -0,0 +1,2 @@
+with({}) {
+};

node_modules/uglify-js/test/unit/scripts.js

@@ -0,0 +1,55 @@
+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 });
+        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);

node_modules/uglify-js/tmp/hoist.js

@@ -0,0 +1,33 @@
+function foo(arg1, arg2, arg3, arg4, arg5, arg6) {
+        var a = 5;
+        {
+                var d = 10, mak = 20, buz = 30;
+                var q = buz * 2;
+        }
+        if (moo) {
+                var a, b, c;
+        }
+        for (var arg1 = 0, d = 20; arg1 < 10; ++arg1)
+                console.log(arg3);
+        for (var i in mak) {}
+        for (j in d) {}
+        var d;
+
+        function test() {
+                
+        };
+
+        //test();
+
+        (function moo(first, second){
+                console.log(first);
+        })(1);
+
+        (function moo(first, second){
+                console.log(moo());
+        })(1);
+}
+
+
+var foo;
+var bar;

node_modules/uglify-js/tmp/instrument.js

@@ -0,0 +1,97 @@
+// 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");
+}

node_modules/uglify-js/tmp/instrument2.js

@@ -0,0 +1,138 @@
+// 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;
+}

node_modules/uglify-js/tmp/test.js

@@ -0,0 +1,30 @@
+#! /usr/bin/env node
+
+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 code = fs.readFileSync("hoist.js", "utf8");
+var ast = jsp.parse(code);
+
+ast = pro.ast_lift_variables(ast);
+
+var w = pro.ast_walker();
+ast = w.with_walkers({
+        "function": function() {
+                var node = w.dive(this); // walk depth first
+                console.log(pro.gen_code(node, { beautify: true }));
+                return node;
+        },
+        "name": function(name) {
+                return [ this[0], "X" ];
+        }
+}, function(){
+        return w.walk(ast);
+});
+
+console.log(pro.gen_code(ast, {
+        beautify: true
+}));

node_modules/uglify-js/uglify-js.js

@@ -0,0 +1,17 @@
+//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