profxadke/commando.html5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

dot.dot.dot.exampol

Browse source
This commit is contained in:
Captain Nick Lucifer* 2023-03-10 23:21:16 +05:45
commit a0bc2d79de
406 changed files with 34577 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

33
node_modules/uglify-js/tmp/hoist.js generated vendored Normal file
View file

@ -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;

97
node_modules/uglify-js/tmp/instrument.js generated vendored Normal file
View file

@ -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");
}

138
node_modules/uglify-js/tmp/instrument2.js generated vendored Normal file
View file

@ -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;
}

30
node_modules/uglify-js/tmp/test.js generated vendored Executable file
View file

@ -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
}));