This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
615 lines
22 KiB
615 lines
22 KiB
/*********************************************************************** |
|
|
|
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 normalize_directives = function(body) { |
|
var in_directive = true; |
|
|
|
for (var i = 0; i < body.length; i++) { |
|
if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) { |
|
body[i] = new AST_Directive({ |
|
start: body[i].start, |
|
end: body[i].end, |
|
value: body[i].body.value |
|
}); |
|
} else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) { |
|
in_directive = false; |
|
} |
|
} |
|
|
|
return body; |
|
}; |
|
|
|
var MOZ_TO_ME = { |
|
Program: function(M) { |
|
return new AST_Toplevel({ |
|
start: my_start_token(M), |
|
end: my_end_token(M), |
|
body: normalize_directives(M.body.map(from_moz)) |
|
}); |
|
}, |
|
FunctionDeclaration: function(M) { |
|
return new AST_Defun({ |
|
start: my_start_token(M), |
|
end: my_end_token(M), |
|
name: from_moz(M.id), |
|
argnames: M.params.map(from_moz), |
|
body: normalize_directives(from_moz(M.body).body) |
|
}); |
|
}, |
|
FunctionExpression: function(M) { |
|
return new AST_Function({ |
|
start: my_start_token(M), |
|
end: my_end_token(M), |
|
name: from_moz(M.id), |
|
argnames: M.params.map(from_moz), |
|
body: normalize_directives(from_moz(M.body).body) |
|
}); |
|
}, |
|
ExpressionStatement: function(M) { |
|
return new AST_SimpleStatement({ |
|
start: my_start_token(M), |
|
end: my_end_token(M), |
|
body: from_moz(M.expression) |
|
}); |
|
}, |
|
TryStatement: function(M) { |
|
var handlers = M.handlers || [M.handler]; |
|
if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) { |
|
throw new Error("Multiple catch clauses are not supported."); |
|
} |
|
return new AST_Try({ |
|
start : my_start_token(M), |
|
end : my_end_token(M), |
|
body : from_moz(M.block).body, |
|
bcatch : from_moz(handlers[0]), |
|
bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null |
|
}); |
|
}, |
|
Property: function(M) { |
|
var key = M.key; |
|
var args = { |
|
start : my_start_token(key), |
|
end : my_end_token(M.value), |
|
key : key.type == "Identifier" ? key.name : key.value, |
|
value : from_moz(M.value) |
|
}; |
|
if (M.kind == "init") return new AST_ObjectKeyVal(args); |
|
args.key = new AST_SymbolMethod({ |
|
name: args.key |
|
}); |
|
args.value = new AST_Accessor(args.value); |
|
if (M.kind == "get") return new AST_ObjectGetter(args); |
|
if (M.kind == "set") return new AST_ObjectSetter(args); |
|
}, |
|
ArrayExpression: function(M) { |
|
return new AST_Array({ |
|
start : my_start_token(M), |
|
end : my_end_token(M), |
|
elements : M.elements.map(function(elem){ |
|
return elem === null ? new AST_Hole() : from_moz(elem); |
|
}) |
|
}); |
|
}, |
|
ObjectExpression: function(M) { |
|
return new AST_Object({ |
|
start : my_start_token(M), |
|
end : my_end_token(M), |
|
properties : M.properties.map(function(prop){ |
|
prop.type = "Property"; |
|
return from_moz(prop) |
|
}) |
|
}); |
|
}, |
|
SequenceExpression: function(M) { |
|
return new AST_Sequence({ |
|
start : my_start_token(M), |
|
end : my_end_token(M), |
|
expressions: 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) |
|
}); |
|
}, |
|
VariableDeclaration: function(M) { |
|
return new (M.kind === "const" ? AST_Const : AST_Var)({ |
|
start : my_start_token(M), |
|
end : my_end_token(M), |
|
definitions : M.declarations.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: |
|
var rx = M.regex; |
|
if (rx && rx.pattern) { |
|
// RegExpLiteral as per ESTree AST spec |
|
args.value = new RegExp(rx.pattern, rx.flags).toString(); |
|
} else { |
|
// support legacy RegExp |
|
args.value = M.regex && M.raw ? M.raw : val; |
|
} |
|
return new AST_RegExp(args); |
|
} |
|
}, |
|
Identifier: function(M) { |
|
var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2]; |
|
return new ( 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 |
|
}); |
|
} |
|
}; |
|
|
|
MOZ_TO_ME.UpdateExpression = |
|
MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) { |
|
var prefix = "prefix" in M ? M.prefix |
|
: M.type == "UnaryExpression" ? true : false; |
|
return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({ |
|
start : my_start_token(M), |
|
end : my_end_token(M), |
|
operator : M.operator, |
|
expression : from_moz(M.argument) |
|
}); |
|
}; |
|
|
|
map("EmptyStatement", AST_EmptyStatement); |
|
map("BlockStatement", AST_BlockStatement, "body@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("VariableDeclarator", AST_VarDef, "id>name, init>value"); |
|
map("CatchClause", AST_Catch, "param>argname, body%body"); |
|
|
|
map("ThisExpression", AST_This); |
|
map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right"); |
|
map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right"); |
|
map("AssignmentExpression", AST_Assign, "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"); |
|
|
|
def_to_moz(AST_Toplevel, function To_Moz_Program(M) { |
|
return to_moz_scope("Program", M); |
|
}); |
|
|
|
def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) { |
|
return { |
|
type: "FunctionDeclaration", |
|
id: to_moz(M.name), |
|
params: M.argnames.map(to_moz), |
|
body: to_moz_scope("BlockStatement", M) |
|
} |
|
}); |
|
|
|
def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) { |
|
return { |
|
type: "FunctionExpression", |
|
id: to_moz(M.name), |
|
params: M.argnames.map(to_moz), |
|
body: to_moz_scope("BlockStatement", M) |
|
} |
|
}); |
|
|
|
def_to_moz(AST_Directive, function To_Moz_Directive(M) { |
|
return { |
|
type: "ExpressionStatement", |
|
expression: { |
|
type: "Literal", |
|
value: M.value |
|
} |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) { |
|
return { |
|
type: "ExpressionStatement", |
|
expression: to_moz(M.body) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) { |
|
return { |
|
type: "SwitchCase", |
|
test: to_moz(M.expression), |
|
consequent: M.body.map(to_moz) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Try, function To_Moz_TryStatement(M) { |
|
return { |
|
type: "TryStatement", |
|
block: to_moz_block(M), |
|
handler: to_moz(M.bcatch), |
|
guardedHandlers: [], |
|
finalizer: to_moz(M.bfinally) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Catch, function To_Moz_CatchClause(M) { |
|
return { |
|
type: "CatchClause", |
|
param: to_moz(M.argname), |
|
guard: null, |
|
body: to_moz_block(M) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) { |
|
return { |
|
type: "VariableDeclaration", |
|
kind: M instanceof AST_Const ? "const" : "var", |
|
declarations: M.definitions.map(to_moz) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) { |
|
return { |
|
type: "SequenceExpression", |
|
expressions: M.expressions.map(to_moz) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) { |
|
var isComputed = M instanceof AST_Sub; |
|
return { |
|
type: "MemberExpression", |
|
object: to_moz(M.expression), |
|
computed: isComputed, |
|
property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property} |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Unary, function To_Moz_Unary(M) { |
|
return { |
|
type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression", |
|
operator: M.operator, |
|
prefix: M instanceof AST_UnaryPrefix, |
|
argument: to_moz(M.expression) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) { |
|
return { |
|
type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression", |
|
left: to_moz(M.left), |
|
operator: M.operator, |
|
right: to_moz(M.right) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) { |
|
return { |
|
type: "ArrayExpression", |
|
elements: M.elements.map(to_moz) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) { |
|
return { |
|
type: "ObjectExpression", |
|
properties: M.properties.map(to_moz) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) { |
|
var key = { |
|
type: "Literal", |
|
value: M.key instanceof AST_SymbolMethod ? M.key.name : M.key |
|
}; |
|
var kind; |
|
if (M instanceof AST_ObjectKeyVal) { |
|
kind = "init"; |
|
} else |
|
if (M instanceof AST_ObjectGetter) { |
|
kind = "get"; |
|
} else |
|
if (M instanceof AST_ObjectSetter) { |
|
kind = "set"; |
|
} |
|
return { |
|
type: "Property", |
|
kind: kind, |
|
key: key, |
|
value: to_moz(M.value) |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Symbol, function To_Moz_Identifier(M) { |
|
var def = M.definition(); |
|
return { |
|
type: "Identifier", |
|
name: def ? def.mangled_name || def.name : M.name |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) { |
|
var value = M.value; |
|
return { |
|
type: "Literal", |
|
value: value, |
|
raw: value.toString(), |
|
regex: { |
|
pattern: value.source, |
|
flags: value.toString().match(/[gimuy]*$/)[0] |
|
} |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Constant, function To_Moz_Literal(M) { |
|
var value = M.value; |
|
if (typeof value === 'number' && (value < 0 || (value === 0 && 1 / value < 0))) { |
|
return { |
|
type: "UnaryExpression", |
|
operator: "-", |
|
prefix: true, |
|
argument: { |
|
type: "Literal", |
|
value: -value, |
|
raw: M.start.raw |
|
} |
|
}; |
|
} |
|
return { |
|
type: "Literal", |
|
value: value, |
|
raw: M.start.raw |
|
}; |
|
}); |
|
|
|
def_to_moz(AST_Atom, function To_Moz_Atom(M) { |
|
return { |
|
type: "Identifier", |
|
name: String(M.value) |
|
}; |
|
}); |
|
|
|
AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast); |
|
AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast); |
|
AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null }); |
|
|
|
AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast); |
|
AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast); |
|
|
|
/* -----[ tools ]----- */ |
|
|
|
function raw_token(moznode) { |
|
if (moznode.type == "Literal") { |
|
return moznode.raw != null ? moznode.raw : moznode.value + ""; |
|
} |
|
} |
|
|
|
function my_start_token(moznode) { |
|
var loc = moznode.loc, start = loc && loc.start; |
|
var range = moznode.range; |
|
return new AST_Token({ |
|
file : loc && loc.source, |
|
line : start && start.line, |
|
col : start && start.column, |
|
pos : range ? range[0] : moznode.start, |
|
endline : start && start.line, |
|
endcol : start && start.column, |
|
endpos : range ? range[0] : moznode.start, |
|
raw : raw_token(moznode), |
|
}); |
|
}; |
|
|
|
function my_end_token(moznode) { |
|
var loc = moznode.loc, end = loc && loc.end; |
|
var range = moznode.range; |
|
return new AST_Token({ |
|
file : loc && loc.source, |
|
line : end && end.line, |
|
col : end && end.column, |
|
pos : range ? range[1] : moznode.end, |
|
endline : end && end.line, |
|
endcol : end && end.column, |
|
endpos : range ? range[1] : moznode.end, |
|
raw : raw_token(moznode), |
|
}); |
|
}; |
|
|
|
function map(moztype, mytype, propmap) { |
|
var moz_to_me = "function From_Moz_" + moztype + "(M){\n"; |
|
moz_to_me += "return new U2." + mytype.name + "({\n" + |
|
"start: my_start_token(M),\n" + |
|
"end: my_end_token(M)"; |
|
|
|
var me_to_moz = "function To_Moz_" + moztype + "(M){\n"; |
|
me_to_moz += "return {\n" + |
|
"type: " + JSON.stringify(moztype); |
|
|
|
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[1], how = m[2], my = m[3]; |
|
moz_to_me += ",\n" + my + ": "; |
|
me_to_moz += ",\n" + moz + ": "; |
|
switch (how) { |
|
case "@": |
|
moz_to_me += "M." + moz + ".map(from_moz)"; |
|
me_to_moz += "M." + my + ".map(to_moz)"; |
|
break; |
|
case ">": |
|
moz_to_me += "from_moz(M." + moz + ")"; |
|
me_to_moz += "to_moz(M." + my + ")"; |
|
break; |
|
case "=": |
|
moz_to_me += "M." + moz; |
|
me_to_moz += "M." + my; |
|
break; |
|
case "%": |
|
moz_to_me += "from_moz(M." + moz + ").body"; |
|
me_to_moz += "to_moz_block(M)"; |
|
break; |
|
default: |
|
throw new Error("Can't understand operator in propmap: " + prop); |
|
} |
|
}); |
|
|
|
moz_to_me += "\n})\n}"; |
|
me_to_moz += "\n}\n}"; |
|
|
|
//moz_to_me = parse(moz_to_me).print_to_string({ beautify: true }); |
|
//me_to_moz = parse(me_to_moz).print_to_string({ beautify: true }); |
|
//console.log(moz_to_me); |
|
|
|
moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")( |
|
exports, my_start_token, my_end_token, from_moz |
|
); |
|
me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")( |
|
to_moz, to_moz_block, to_moz_scope |
|
); |
|
MOZ_TO_ME[moztype] = moz_to_me; |
|
def_to_moz(mytype, me_to_moz); |
|
}; |
|
|
|
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; |
|
}; |
|
|
|
function set_moz_loc(mynode, moznode, myparent) { |
|
var start = mynode.start; |
|
var end = mynode.end; |
|
if (start.pos != null && end.endpos != null) { |
|
moznode.range = [start.pos, end.endpos]; |
|
} |
|
if (start.line) { |
|
moznode.loc = { |
|
start: {line: start.line, column: start.col}, |
|
end: end.endline ? {line: end.endline, column: end.endcol} : null |
|
}; |
|
if (start.file) { |
|
moznode.loc.source = start.file; |
|
} |
|
} |
|
return moznode; |
|
}; |
|
|
|
function def_to_moz(mytype, handler) { |
|
mytype.DEFMETHOD("to_mozilla_ast", function() { |
|
return set_moz_loc(this, handler(this)); |
|
}); |
|
}; |
|
|
|
function to_moz(node) { |
|
return node != null ? node.to_mozilla_ast() : null; |
|
}; |
|
|
|
function to_moz_block(node) { |
|
return { |
|
type: "BlockStatement", |
|
body: node.body.map(to_moz) |
|
}; |
|
}; |
|
|
|
function to_moz_scope(type, node) { |
|
var body = node.body.map(to_moz); |
|
if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) { |
|
body.unshift(to_moz(new AST_EmptyStatement(node.body[0]))); |
|
} |
|
return { |
|
type: type, |
|
body: body |
|
}; |
|
}; |
|
})();
|
|
|