mirror of
https://git.sb/baoshuo/OI-codes.git
synced 2024-09-19 16:45:25 +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()));
|