sprockets-browserify 0.1.2 → 0.2.0

data/node_modules/browserify/node_modules/umd/node_modules/uglify-js/lib/mozilla-ast.js

@@ -0,0 +1,265 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+"use strict";
+
+(function(){
+
+    var MOZ_TO_ME = {
+        TryStatement : function(M) {
+            return new AST_Try({
+                start    : my_start_token(M),
+                end      : my_end_token(M),
+                body     : from_moz(M.block).body,
+                bcatch   : from_moz(M.handlers[0]),
+                bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
+            });
+        },
+        CatchClause : function(M) {
+            return new AST_Catch({
+                start   : my_start_token(M),
+                end     : my_end_token(M),
+                argname : from_moz(M.param),
+                body    : from_moz(M.body).body
+            });
+        },
+        ObjectExpression : function(M) {
+            return new AST_Object({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                properties : M.properties.map(function(prop){
+                    var key = prop.key;
+                    var name = key.type == "Identifier" ? key.name : key.value;
+                    var args = {
+                        start    : my_start_token(key),
+                        end      : my_end_token(prop.value),
+                        key      : name,
+                        value    : from_moz(prop.value)
+                    };
+                    switch (prop.kind) {
+                      case "init":
+                        return new AST_ObjectKeyVal(args);
+                      case "set":
+                        args.value.name = from_moz(key);
+                        return new AST_ObjectSetter(args);
+                      case "get":
+                        args.value.name = from_moz(key);
+                        return new AST_ObjectGetter(args);
+                    }
+                })
+            });
+        },
+        SequenceExpression : function(M) {
+            return AST_Seq.from_array(M.expressions.map(from_moz));
+        },
+        MemberExpression : function(M) {
+            return new (M.computed ? AST_Sub : AST_Dot)({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                property   : M.computed ? from_moz(M.property) : M.property.name,
+                expression : from_moz(M.object)
+            });
+        },
+        SwitchCase : function(M) {
+            return new (M.test ? AST_Case : AST_Default)({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                expression : from_moz(M.test),
+                body       : M.consequent.map(from_moz)
+            });
+        },
+        Literal : function(M) {
+            var val = M.value, args = {
+                start  : my_start_token(M),
+                end    : my_end_token(M)
+            };
+            if (val === null) return new AST_Null(args);
+            switch (typeof val) {
+              case "string":
+                args.value = val;
+                return new AST_String(args);
+              case "number":
+                args.value = val;
+                return new AST_Number(args);
+              case "boolean":
+                return new (val ? AST_True : AST_False)(args);
+              default:
+                args.value = val;
+                return new AST_RegExp(args);
+            }
+        },
+        UnaryExpression: From_Moz_Unary,
+        UpdateExpression: From_Moz_Unary,
+        Identifier: function(M) {
+            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
+            return new (M.name == "this" ? AST_This
+                        : p.type == "LabeledStatement" ? AST_Label
+                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
+                        : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
+                        : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
+                        : p.type == "CatchClause" ? AST_SymbolCatch
+                        : p.type == "BreakStatement" || p.type == "ContinueStatement" ? AST_LabelRef
+                        : AST_SymbolRef)({
+                            start : my_start_token(M),
+                            end   : my_end_token(M),
+                            name  : M.name
+                        });
+        }
+    };
+
+    function From_Moz_Unary(M) {
+        return new (M.prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
+            start      : my_start_token(M),
+            end        : my_end_token(M),
+            operator   : M.operator,
+            expression : from_moz(M.argument)
+        })
+    };
+
+    var ME_TO_MOZ = {};
+
+    map("Node", AST_Node);
+    map("Program", AST_Toplevel, "body@body");
+    map("Function", AST_Function, "id>name, params@argnames, body%body");
+    map("EmptyStatement", AST_EmptyStatement);
+    map("BlockStatement", AST_BlockStatement, "body@body");
+    map("ExpressionStatement", AST_SimpleStatement, "expression>body");
+    map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
+    map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
+    map("BreakStatement", AST_Break, "label>label");
+    map("ContinueStatement", AST_Continue, "label>label");
+    map("WithStatement", AST_With, "object>expression, body>body");
+    map("SwitchStatement", AST_Switch, "discriminant>expression, cases@body");
+    map("ReturnStatement", AST_Return, "argument>value");
+    map("ThrowStatement", AST_Throw, "argument>value");
+    map("WhileStatement", AST_While, "test>condition, body>body");
+    map("DoWhileStatement", AST_Do, "test>condition, body>body");
+    map("ForStatement", AST_For, "init>init, test>condition, update>step, body>body");
+    map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
+    map("DebuggerStatement", AST_Debugger);
+    map("FunctionDeclaration", AST_Defun, "id>name, params@argnames, body%body");
+    map("VariableDeclaration", AST_Var, "declarations@definitions");
+    map("VariableDeclarator", AST_VarDef, "id>name, init>value");
+
+    map("ThisExpression", AST_This);
+    map("ArrayExpression", AST_Array, "elements@elements");
+    map("FunctionExpression", AST_Function, "id>name, params@argnames, body%body");
+    map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
+    map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
+    map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
+    map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
+    map("NewExpression", AST_New, "callee>expression, arguments@args");
+    map("CallExpression", AST_Call, "callee>expression, arguments@args");
+
+    /* -----[ tools ]----- */
+
+    function my_start_token(moznode) {
+        return new AST_Token({
+            file   : moznode.loc && moznode.loc.source,
+            line   : moznode.loc && moznode.loc.start.line,
+            col    : moznode.loc && moznode.loc.start.column,
+            pos    : moznode.start,
+            endpos : moznode.start
+        });
+    };
+
+    function my_end_token(moznode) {
+        return new AST_Token({
+            file   : moznode.loc && moznode.loc.source,
+            line   : moznode.loc && moznode.loc.end.line,
+            col    : moznode.loc && moznode.loc.end.column,
+            pos    : moznode.end,
+            endpos : moznode.end
+        });
+    };
+
+    function map(moztype, mytype, propmap) {
+        var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
+        moz_to_me += "return new mytype({\n" +
+            "start: my_start_token(M),\n" +
+            "end: my_end_token(M)";
+
+        if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop){
+            var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
+            if (!m) throw new Error("Can't understand property map: " + prop);
+            var moz = "M." + m[1], how = m[2], my = m[3];
+            moz_to_me += ",\n" + my + ": ";
+            if (how == "@") {
+                moz_to_me += moz + ".map(from_moz)";
+            } else if (how == ">") {
+                moz_to_me += "from_moz(" + moz + ")";
+            } else if (how == "=") {
+                moz_to_me += moz;
+            } else if (how == "%") {
+                moz_to_me += "from_moz(" + moz + ").body";
+            } else throw new Error("Can't understand operator in propmap: " + prop);
+        });
+        moz_to_me += "\n})}";
+
+        // moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
+        // console.log(moz_to_me);
+
+        moz_to_me = new Function("mytype", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
+            mytype, my_start_token, my_end_token, from_moz
+        );
+        return MOZ_TO_ME[moztype] = moz_to_me;
+    };
+
+    var FROM_MOZ_STACK = null;
+
+    function from_moz(node) {
+        FROM_MOZ_STACK.push(node);
+        var ret = node != null ? MOZ_TO_ME[node.type](node) : null;
+        FROM_MOZ_STACK.pop();
+        return ret;
+    };
+
+    AST_Node.from_mozilla_ast = function(node){
+        var save_stack = FROM_MOZ_STACK;
+        FROM_MOZ_STACK = [];
+        var ast = from_moz(node);
+        FROM_MOZ_STACK = save_stack;
+        return ast;
+    };
+
+})();