diff options
Diffstat (limited to 'signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org')
| -rw-r--r-- | signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org | 574 |
1 files changed, 574 insertions, 0 deletions
diff --git a/signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org b/signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org new file mode 100644 index 0000000..4d01fdf --- /dev/null +++ b/signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org @@ -0,0 +1,574 @@ +#+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 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 && 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 |