mirror of
https://git.sb/baoshuo/OI-codes.git
synced 2024-11-24 23:28:48 +00:00
417 lines
11 KiB
JavaScript
417 lines
11 KiB
JavaScript
/*! JSFuck 0.5.0 - http://jsfuck.com */
|
|
|
|
const MIN = 32,
|
|
MAX = 126;
|
|
|
|
const SIMPLE = {
|
|
false: "![]",
|
|
true: "!![]",
|
|
undefined: "[][[]]",
|
|
NaN: "+[![]]",
|
|
Infinity: "+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])", // +"1e1000"
|
|
};
|
|
|
|
const CONSTRUCTORS = {
|
|
Array: "[]",
|
|
Number: "(+[])",
|
|
String: "([]+[])",
|
|
Boolean: "(![])",
|
|
Function: '[]["flat"]',
|
|
RegExp: 'Function("return/"+false+"/")()',
|
|
Object: '[]["entries"]()',
|
|
};
|
|
|
|
const MAPPING = {
|
|
a: '(false+"")[1]',
|
|
b: '([]["entries"]()+"")[2]',
|
|
c: '([]["flat"]+"")[3]',
|
|
d: '(undefined+"")[2]',
|
|
e: '(true+"")[3]',
|
|
f: '(false+"")[0]',
|
|
g: "(false+[0]+String)[20]",
|
|
h: '(+(101))["to"+String["name"]](21)[1]',
|
|
i: "([false]+undefined)[10]",
|
|
j: '([]["entries"]()+"")[3]',
|
|
k: '(+(20))["to"+String["name"]](21)',
|
|
l: '(false+"")[2]',
|
|
m: '(Number+"")[11]',
|
|
n: '(undefined+"")[1]',
|
|
o: '(true+[]["flat"])[10]',
|
|
p: '(+(211))["to"+String["name"]](31)[1]',
|
|
q: '("")["fontcolor"]([0]+false+")[20]',
|
|
r: '(true+"")[1]',
|
|
s: '(false+"")[3]',
|
|
t: '(true+"")[0]',
|
|
u: '(undefined+"")[0]',
|
|
v: '(+(31))["to"+String["name"]](32)',
|
|
w: '(+(32))["to"+String["name"]](33)',
|
|
x: '(+(101))["to"+String["name"]](34)[1]',
|
|
y: "(NaN+[Infinity])[10]",
|
|
z: '(+(35))["to"+String["name"]](36)',
|
|
|
|
A: '(NaN+[]["entries"]())[11]',
|
|
B: "(+[]+Boolean)[10]",
|
|
C: 'Function("return escape")()(("")["italics"]())[2]',
|
|
D: 'Function("return escape")()([]["flat"])["slice"]("-1")',
|
|
E: '(RegExp+"")[12]',
|
|
F: "(+[]+Function)[10]",
|
|
G: '(false+Function("return Date")()())[30]',
|
|
H: null,
|
|
I: '(Infinity+"")[0]',
|
|
J: null,
|
|
K: null,
|
|
L: null,
|
|
M: '(true+Function("return Date")()())[30]',
|
|
N: '(NaN+"")[0]',
|
|
O: "(+[]+Object)[10]",
|
|
P: null,
|
|
Q: null,
|
|
R: "(+[]+RegExp)[10]",
|
|
S: "(+[]+String)[10]",
|
|
T: '(NaN+Function("return Date")()())[30]',
|
|
U: '(NaN+Object()["to"+String["name"]]["call"]())[11]',
|
|
V: null,
|
|
W: null,
|
|
X: null,
|
|
Y: null,
|
|
Z: null,
|
|
|
|
" ": '(NaN+[]["flat"])[11]',
|
|
"!": null,
|
|
'"': '("")["fontcolor"]()[12]',
|
|
"#": null,
|
|
$: null,
|
|
"%": 'Function("return escape")()([]["flat"])[21]',
|
|
"&": '("")["fontcolor"](")[13]',
|
|
"'": null,
|
|
"(": '([]["flat"]+"")[13]',
|
|
")": '([0]+false+[]["flat"])[20]',
|
|
"*": null,
|
|
"+": "(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[2]",
|
|
",": '[[]]["concat"]([[]])+""',
|
|
"-": '(+(.+[0000001])+"")[2]',
|
|
".": "(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]",
|
|
"/": '(false+[0])["italics"]()[10]',
|
|
":": '(RegExp()+"")[3]',
|
|
";": '("")["fontcolor"](NaN+")[21]',
|
|
"<": '("")["italics"]()[0]',
|
|
"=": '("")["fontcolor"]()[11]',
|
|
">": '("")["italics"]()[2]',
|
|
"?": '(RegExp()+"")[2]',
|
|
"@": null,
|
|
"[": '([]["entries"]()+"")[0]',
|
|
"\\": '(RegExp("/")+"")[1]',
|
|
"]": '([]["entries"]()+"")[22]',
|
|
"^": null,
|
|
_: null,
|
|
"`": null,
|
|
"{": '(true+[]["flat"])[20]',
|
|
"|": null,
|
|
"}": '([]["flat"]+"")["slice"]("-1")',
|
|
"~": null,
|
|
};
|
|
|
|
const GLOBAL = 'Function("return this")()';
|
|
|
|
function fillMissingDigits() {
|
|
var output, number, i;
|
|
|
|
for (number = 0; number < 10; number++) {
|
|
output = "+[]";
|
|
|
|
if (number > 0) {
|
|
output = "+!" + output;
|
|
}
|
|
for (i = 1; i < number; i++) {
|
|
output = "+!+[]" + output;
|
|
}
|
|
if (number > 1) {
|
|
output = output.substr(1);
|
|
}
|
|
|
|
MAPPING[number] = "[" + output + "]";
|
|
}
|
|
}
|
|
|
|
function replaceMap() {
|
|
var character = "",
|
|
value,
|
|
i,
|
|
key;
|
|
|
|
function replace(pattern, replacement) {
|
|
value = value.replace(new RegExp(pattern, "gi"), replacement);
|
|
}
|
|
|
|
function digitReplacer(_, x) {
|
|
return MAPPING[x];
|
|
}
|
|
|
|
function numberReplacer(_, y) {
|
|
var values = y.split("");
|
|
var head = +values.shift();
|
|
var output = "+[]";
|
|
|
|
if (head > 0) {
|
|
output = "+!" + output;
|
|
}
|
|
for (i = 1; i < head; i++) {
|
|
output = "+!+[]" + output;
|
|
}
|
|
if (head > 1) {
|
|
output = output.substr(1);
|
|
}
|
|
|
|
return [output]
|
|
.concat(values)
|
|
.join("+")
|
|
.replace(/(\d)/g, digitReplacer);
|
|
}
|
|
|
|
for (i = MIN; i <= MAX; i++) {
|
|
character = String.fromCharCode(i);
|
|
value = MAPPING[character];
|
|
if (!value) {
|
|
continue;
|
|
}
|
|
|
|
for (key in CONSTRUCTORS) {
|
|
replace("\\b" + key, CONSTRUCTORS[key] + '["constructor"]');
|
|
}
|
|
|
|
for (key in SIMPLE) {
|
|
replace(key, SIMPLE[key]);
|
|
}
|
|
|
|
replace("(\\d\\d+)", numberReplacer);
|
|
replace("\\((\\d)\\)", digitReplacer);
|
|
replace("\\[(\\d)\\]", digitReplacer);
|
|
|
|
replace("GLOBAL", GLOBAL);
|
|
replace('\\+""', "+[]");
|
|
replace('""', "[]+[]");
|
|
|
|
MAPPING[character] = value;
|
|
}
|
|
}
|
|
|
|
function replaceStrings() {
|
|
var regEx = /[^\[\]\(\)\!\+]{1}/g,
|
|
all,
|
|
value,
|
|
missing,
|
|
count = MAX - MIN;
|
|
|
|
function findMissing() {
|
|
var all,
|
|
value,
|
|
done = false;
|
|
|
|
missing = {};
|
|
|
|
for (all in MAPPING) {
|
|
value = MAPPING[all];
|
|
|
|
if (value && value.match(regEx)) {
|
|
missing[all] = value;
|
|
done = true;
|
|
}
|
|
}
|
|
|
|
return done;
|
|
}
|
|
|
|
function mappingReplacer(a, b) {
|
|
return b.split("").join("+");
|
|
}
|
|
|
|
function valueReplacer(c) {
|
|
return missing[c] ? c : MAPPING[c];
|
|
}
|
|
|
|
for (all in MAPPING) {
|
|
if (MAPPING[all]) {
|
|
MAPPING[all] = MAPPING[all].replace(
|
|
/\"([^\"]+)\"/gi,
|
|
mappingReplacer
|
|
);
|
|
}
|
|
}
|
|
|
|
while (findMissing()) {
|
|
for (all in missing) {
|
|
value = MAPPING[all];
|
|
value = value.replace(regEx, valueReplacer);
|
|
|
|
MAPPING[all] = value;
|
|
missing[all] = value;
|
|
}
|
|
|
|
if (count-- === 0) {
|
|
console.error("Could not compile the following chars:", missing);
|
|
}
|
|
}
|
|
}
|
|
|
|
function escapeSequence(c) {
|
|
var cc = c.charCodeAt(0);
|
|
if (cc < 256) {
|
|
return "\\" + cc.toString(8);
|
|
} else {
|
|
var cc16 = cc.toString(16);
|
|
return "\\u" + ("0000" + cc16).substring(cc16.length);
|
|
}
|
|
}
|
|
|
|
function escapeSequenceForReplace(c) {
|
|
return escapeSequence(c).replace("\\", "t");
|
|
}
|
|
|
|
function encode(input, wrapWithEval, runInParentScope) {
|
|
var output = [];
|
|
|
|
if (!input) {
|
|
return "";
|
|
}
|
|
|
|
var unmappped = "";
|
|
for (var k in MAPPING) {
|
|
if (MAPPING[k]) {
|
|
unmappped += k;
|
|
}
|
|
}
|
|
unmappped = unmappped.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
unmappped = new RegExp("[^" + unmappped + "]", "g");
|
|
var unmappedCharactersCount = (input.match(unmappped) || []).length;
|
|
if (unmappedCharactersCount > 1) {
|
|
// Without this optimization one unmapped caracter has encoded length
|
|
// of about 3600 characters. Every additional unmapped character adds
|
|
// 2000 to the total length. For example, the lenght of `~` is 3605,
|
|
// `~~` is 5600, and `~~~` is 7595.
|
|
//
|
|
// The loader with replace has encoded length of about 5300 characters
|
|
// and every additional character adds 100 to the total length.
|
|
// In the same example the length of `~~` becomes 5371 and `~~~` -- 5463.
|
|
//
|
|
// So, when we have more than one unmapped character we want to encode whole input
|
|
// except select characters (that have encoded length less than about 70)
|
|
// into an escape sequence.
|
|
//
|
|
// NOTE: `t` should be escaped!
|
|
input = input.replace(
|
|
/[^0123456789.adefilnrsuN]/g,
|
|
escapeSequenceForReplace
|
|
);
|
|
} else if (unmappedCharactersCount > 0) {
|
|
//Because we will wrap the input into a string we need to escape Backslash
|
|
// and Double quote characters (we do not need to worry about other characters
|
|
// because they are not mapped explicitly).
|
|
// The JSFuck-encoded representation of `\` is 2121 symbols,
|
|
// so esacped `\` is 4243 symbols and escaped `"` is 2261 symbols
|
|
// however the escape sequence of that characters are
|
|
// 2168 and 2155 symbols respectively, so it's more practical to
|
|
// rewrite them as escape sequences.
|
|
input = input.replace(/["\\]/g, escapeSequence);
|
|
//Convert all unmapped characters to escape sequence
|
|
input = input.replace(unmappped, escapeSequence);
|
|
}
|
|
|
|
var r = "";
|
|
for (var i in SIMPLE) {
|
|
r += i + "|";
|
|
}
|
|
r += ".";
|
|
|
|
input.replace(new RegExp(r, "g"), function (c) {
|
|
var replacement = SIMPLE[c];
|
|
if (replacement) {
|
|
output.push("(" + replacement + "+[])");
|
|
} else {
|
|
replacement = MAPPING[c];
|
|
if (replacement) {
|
|
output.push(replacement);
|
|
} else {
|
|
throw new Error("Found unmapped character: " + c);
|
|
}
|
|
}
|
|
});
|
|
|
|
output = output.join("+");
|
|
|
|
if (/^\d$/.test(input)) {
|
|
output += "+[]";
|
|
}
|
|
|
|
if (unmappedCharactersCount > 1) {
|
|
// replace `t` with `\\`
|
|
output =
|
|
"(" +
|
|
output +
|
|
")[" +
|
|
encode("split") +
|
|
"](" +
|
|
encode("t") +
|
|
")[" +
|
|
encode("join") +
|
|
"](" +
|
|
encode("\\") +
|
|
")";
|
|
}
|
|
|
|
if (unmappedCharactersCount > 0) {
|
|
output =
|
|
"[][" +
|
|
encode("flat") +
|
|
"]" +
|
|
"[" +
|
|
encode("constructor") +
|
|
"]" +
|
|
"(" +
|
|
encode('return"') +
|
|
"+" +
|
|
output +
|
|
"+" +
|
|
encode('"') +
|
|
")()";
|
|
}
|
|
|
|
if (wrapWithEval) {
|
|
if (runInParentScope) {
|
|
output =
|
|
"[][" +
|
|
encode("flat") +
|
|
"]" +
|
|
"[" +
|
|
encode("constructor") +
|
|
"]" +
|
|
"(" +
|
|
encode("return eval") +
|
|
")()" +
|
|
"(" +
|
|
output +
|
|
")";
|
|
} else {
|
|
output =
|
|
"[][" +
|
|
encode("flat") +
|
|
"]" +
|
|
"[" +
|
|
encode("constructor") +
|
|
"]" +
|
|
"(" +
|
|
output +
|
|
")()";
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
fillMissingDigits();
|
|
replaceMap();
|
|
replaceStrings();
|
|
|
|
/* ============================================= */
|
|
|
|
print(encode(readline()));
|