0% found this document useful (0 votes)

8 views337 pages

Lafferv2 UserScript for Moomoo.io

Uploaded by

m.oztrk1666

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

8 views337 pages

Lafferv2 UserScript for Moomoo.io

Uploaded by

m.oztrk1666

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

// ==UserScript==

// @name Lafferv2
// @namespace Mod
// @author Laffer24,zylex,Anna
// @description - (made a preplacer bc he deleted it line: 12152)
// @version v2
// @match *://*.[Link]/*
// @grant none
// @downloadURL [Link]
// @updateURL [Link]
// ==/UserScript==
let autoVelocityTickToggled = false;
let wsAddress;
let autogathering = false;
let autoOneFrameToggled = true;
let settings = {
botplatformplacer: false,
botcount: 40,
botname: "Helper",
gamezoom: 100,
x18ksync: true,
chatlog: false,
spampreplace: true,
autoPlace: true,
};

/***/ "./node_modules/bad-words/lib/[Link]":
/*!************************************************!*\
!*** ./node_modules/bad-words/lib/[Link] ***!
\************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

const localList = __webpack_require__(/! ./[Link] /

"./node_modules/bad-words/lib/[Link]").words;
const baseList = __webpack_require__(/*! badwords-list */
"./node_modules/badwords-list/lib/[Link]").array;

class Filter {

/**
* Filter constructor.
* @constructor
* @param {object} options - Filter instance options
* @param {boolean} [Link] - Instantiate filter with no blacklist
* @param {array} [Link] - Instantiate filter with custom list
* @param {string} [Link] - Character used to replace profane words.
* @param {string} [Link] - Regular expression used to sanitize words
before comparing them to blacklist.
* @param {string} [Link] - Regular expression used to replace
profane words with placeHolder.
*/
constructor(options = {}) {
[Link](this, {
list: [Link] && [] ||
[Link](localList, [baseList, [Link] || []]),
exclude: [Link] || [],
placeHolder: [Link] || '*',
regex: [Link] || /[^a-zA-Z0-9|\$|\@]|\^/g,
replaceRegex: [Link] || /\w/g
})
}

/**
* Determine if a string contains profane language.
* @param {string} string - String to evaluate for profanity.
*/
isProfane(string) {
return [Link]
.filter((word) => {
const wordExp = new RegExp(`\\b${[Link](/(\W)/g, '\\
$1')}\\b`, 'gi');
return ![Link]([Link]()) &&
[Link](string);
})
.length > 0 || false;
}

/**
* Replace a word with placeHolder characters;
* @param {string} string - String to replace.
*/
replaceWord(string) {
return string
.replace([Link], '')
.replace([Link], [Link]);
}

/**
* Evaluate a string for profanity and return an edited version.
* @param {string} string - Sentence to filter.
*/
clean(string) {
return [Link](/\b/).map((word) => {
return [Link](word) ? [Link](word) : word;
}).join('');
}

/**
* Add word(s) to blacklist filter / remove words from whitelist filter
* @param {...string} word - Word(s) to add to blacklist
*/
addWords() {
let words = [Link](arguments);

[Link](...words);

words
.map(word => [Link]())
.forEach((word) => {
if ([Link](word)) {
[Link]([Link](word), 1);
}
});
}

/**
* Add words to whitelist filter
* @param {...string} word - Word(s) to add to whitelist.
*/
removeWords() {
[Link](...[Link](arguments).map(word =>
[Link]()));
}
}

[Link] = Filter;

/***/ }),

/***/ "./node_modules/bad-words/lib/[Link]":
/*!**********************************************!*\
!*** ./node_modules/bad-words/lib/[Link] ***!
\**********************************************/
/*! exports provided: words, default */
/***/ (function(module) {

[Link] = {"words":
["ahole","anus","ash0le","ash0les","asholes","ass","Ass
Monkey","Assface","assh0le","assh0lez","asshole","assholes","assholz","asswipe","az
zhole","bassterds","bastard","bastards","bastardz","basterds","basterdz","Biatch","
bitch","bitches","Blow
Job","boffing","butthole","buttwipe","c0ck","c0cks","c0k","Carpet
Muncher","cawk","cawks","Clit","cnts","cntz","cock","cockhead","cock-
head","cocks","CockSucker","cock-
sucker","crap","cum","cunt","cunts","cuntz","dick","dild0","dild0s","dildo","dildos
","dilld0","dilld0s","dominatricks","dominatrics","dominatrix","dyke","enema","f u
c k","f u c k e
r","fag","fag1t","faget","fagg1t","faggit","faggot","fagg0t","fagit","fags","fagz",
"faig","faigs","fart","flipping the
bird","fuck","fucker","fuckin","fucking","fucks","Fudge
Packer","fuk","Fukah","Fuken","fuker","Fukin","Fukk","Fukkah","Fukken","Fukker","Fu
kkin","g00k","God-
damned","h00r","h0ar","h0re","hells","hoar","hoor","hoore","jackoff","jap","japs","
jerk-
off","jisim","jiss","jizm","jizz","knob","knobs","knobz","kunt","kunts","kuntz","Le
zzian","Lipshits","Lipshitz","masochist","masokist","massterbait","masstrbait","mas
strbate","masterbaiter","masterbate","masterbates","Motha Fucker","Motha
Fuker","Motha Fukkah","Motha Fukker","Mother Fucker","Mother Fukah","Mother
Fuker","Mother Fukkah","Mother Fukker","mother-fucker","Mutha Fucker","Mutha
Fukah","Mutha Fuker","Mutha Fukkah","Mutha
Fukker","n1gr","nastt","nigger;","nigur;","niiger;","niigr;","orafis","orgasim;","o
rgasm","orgasum","oriface","orifice","orifiss","packi","packie","packy","paki","pak
ie","paky","pecker","peeenus","peeenusss","peenus","peinus","pen1s","penas","penis"
,"penis-
breath","penus","penuus","Phuc","Phuck","Phuk","Phuker","Phukker","polac","polack",
"polak","Poonani","pr1c","pr1ck","pr1k","pusse","pussee","pussy","puuke","puuker","
queer","queers","queerz","qweers","qweerz","qweir","recktum","rectum","retard","sad
ist","scank","schlong","screwing","semen","sex","sexy","Sh!
t","sh1t","sh1ter","sh1ts","sh1tter","sh1tz","shit","shits","shitter","Shitty","Shi
ty","shitz","Shyt","Shyte","Shytty","Shyty","skanck","skank","skankee","skankey","s
kanks","Skanky","slag","slut","sluts","Slutty","slutz","son-of-a-
bitch","tit","turd","va1jina","vag1na","vagiina","vagina","vaj1na","vajina","vullva
","vulva","w0p","wh00r","wh0re","whore","xrated","xxx","b!
+ch","bitch","blowjob","clit","arschloch","fuck","shit","ass","asshole","b!
tch","b17ch","b1tch","bastard","bi+ch","boiolas","buceta","c0ck","cawk","chink","ci
pa","clits","cock","cum","cunt","dildo","dirsa","ejakulate","fatass","fcuk","fuk","
fux0r","hoer","hore","jism","kawk","l3itch","l3i+ch","lesbian","masturbate","master
bat*","masterbat3","motherfucker","s.o.b.","mofo","nazi","nigga","nigger","nutsack"
,"phuck","pimpis","pusse","pussy","scrotum","sh!t","shemale","shi+","sh!
+","slut","smut","teets","tits","boobs","b00bs","teez","testical","testicle","titt"
,"w00se","jackoff","wank","whoar","whore","*damn","*dyke","*fuck*","*shit*","@$
$","amcik","andskota","arse*","assrammer","ayir","bi7ch","bitch*","bollock*","breas
ts","butt-
pirate","cabron","cazzo","chraa","chuj","Cock*","cunt*","d4mn","daygo","dego","dick
*","dike*","dupa","dziwka","ejackulate","Ekrem*","Ekto","enculer","faen","fag*","fa
nculo","fanny","feces","feg","Felcher","ficken","fitt*","Flikker","foreskin","Fotze
","Fu(*","fuk*","futkretzn","gook","guiena","h0r","h4x0r","hell","helvete","hoer*",
"honkey","Huevon","hui","injun","jizz","kanker*","kike","klootzak","kraut","knulle"
,"kuk","kuksuger","Kurac","kurwa","kusi*","kyrpa*","lesbo","mamhoon","masturbat*","
merd*","mibun","monkleigh","mouliewop","muie","mulkku","muschi","nazis","nepesaurio
","nigger*","orospu","paska*","perse","picka","pierdol*","pillu*","pimmel","piss*",
"pizda","poontsee","poop","porn","p0rn","pr0n","preteen","pula","pule","puta","puto
","qahbeh","queef*","rautenberg","schaffer","scheiss*","schlampe","schmuck","screw"
,"sh!
t*","sharmuta","sharmute","shipal","shiz","skribz","skurwysyn","sphencter","spic","
spierdalaj","splooge","suka","b00b*","testicle*","titt*","twat","vittu","wank*","we
tback*","wichser","wop*","yed","zabourah"]};

/***/ }),

/***/ "./node_modules/badwords-list/lib/[Link]":
/*!*************************************************!*\
!*** ./node_modules/badwords-list/lib/[Link] ***!
\*************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

[Link] = ["4r5e", "5h1t", "5hit", "a55", "anal", "anus", "ar5e",

"arrse", "arse", "ass", "ass-fucker", "asses", "assfucker", "assfukka", "asshole",
"assholes", "asswhole", "a_s_s", "b!tch", "b00bs", "b17ch", "b1tch", "ballbag",
"balls", "ballsack", "bastard", "beastial", "beastiality", "bellend", "bestial",
"bestiality", "bi+ch", "biatch", "bitch", "bitcher", "bitchers", "bitches",
"bitchin", "bitching", "bloody", "blow job", "blowjob", "blowjobs", "boiolas",
"bollock", "bollok", "boner", "boob", "boobs", "booobs", "boooobs", "booooobs",
"booooooobs", "breasts", "buceta", "bugger", "bum", "bunny fucker", "butt",
"butthole", "buttmuch", "buttplug", "c0ck", "c0cksucker", "carpet muncher", "cawk",
"chink", "cipa", "cl1t", "clit", "clitoris", "clits", "cnut", "cock", "cock-
sucker", "cockface", "cockhead", "cockmunch", "cockmuncher", "cocks", "cocksuck",
"cocksucked", "cocksucker", "cocksucking", "cocksucks", "cocksuka", "cocksukka",
"cok", "cokmuncher", "coksucka", "coon", "cox", "crap", "cum", "cummer", "cumming",
"cums", "cumshot", "cunilingus", "cunillingus", "cunnilingus", "cunt", "cuntlick",
"cuntlicker", "cuntlicking", "cunts", "cyalis", "cyberfuc", "cyberfuck",
"cyberfucked", "cyberfucker", "cyberfuckers", "cyberfucking", "d1ck", "damn",
"dick", "dickhead", "dildo", "dildos", "dink", "dinks", "dirsa", "dlck", "dog-
fucker", "doggin", "dogging", "donkeyribber", "doosh", "duche", "dyke",
"ejaculate", "ejaculated", "ejaculates", "ejaculating", "ejaculatings",
"ejaculation", "ejakulate", "f u c k", "f u c k e r", "f4nny", "fag", "fagging",
"faggitt", "faggot", "faggs", "fagot", "fagots", "fags", "fanny", "fannyflaps",
"fannyfucker", "fanyy", "fatass", "fcuk", "fcuker", "fcuking", "feck", "fecker",
"felching", "fellate", "fellatio", "fingerfuck", "fingerfucked", "fingerfucker",
"fingerfuckers", "fingerfucking", "fingerfucks", "fistfuck", "fistfucked",
"fistfucker", "fistfuckers", "fistfucking", "fistfuckings", "fistfucks", "flange",
"fook", "fooker", "fuck", "fucka", "fucked", "fucker", "fuckers", "fuckhead",
"fuckheads", "fuckin", "fucking", "fuckings", "fuckingshitmotherfucker", "fuckme",
"fucks", "fuckwhit", "fuckwit", "fudge packer", "fudgepacker", "fuk", "fuker",
"fukker", "fukkin", "fuks", "fukwhit", "fukwit", "fux", "fux0r", "f_u_c_k",
"gangbang", "gangbanged", "gangbangs", "gaylord", "gaysex", "goatse", "God", "god-
dam", "god-damned", "goddamn", "goddamned", "hardcoresex", "hell", "heshe", "hoar",
"hoare", "hoer", "homo", "hore", "horniest", "horny", "hotsex", "jack-off",
"jackoff", "jap", "jerk-off", "jism", "jiz", "jizm", "jizz", "kawk", "knob",
"knobead", "knobed", "knobend", "knobhead", "knobjocky", "knobjokey", "kock",
"kondum", "kondums", "kum", "kummer", "kumming", "kums", "kunilingus", "l3i+ch",
"l3itch", "labia", "lust", "lusting", "m0f0", "m0fo", "m45terbate", "ma5terb8",
"ma5terbate", "masochist", "master-bate", "masterb8", "masterbat*", "masterbat3",
"masterbate", "masterbation", "masterbations", "masturbate", "mo-fo", "mof0",
"mofo", "mothafuck", "mothafucka", "mothafuckas", "mothafuckaz", "mothafucked",
"mothafucker", "mothafuckers", "mothafuckin", "mothafucking", "mothafuckings",
"mothafucks", "mother fucker", "motherfuck", "motherfucked", "motherfucker",
"motherfuckers", "motherfuckin", "motherfucking", "motherfuckings", "motherfuckka",
"motherfucks", "muff", "mutha", "muthafecker", "muthafuckker", "muther",
"mutherfucker", "n1gga", "n1gger", "nazi", "nigg3r", "nigg4h", "nigga", "niggah",
"niggas", "niggaz", "nigger", "niggers", "nob", "nob jokey", "nobhead", "nobjocky",
"nobjokey", "numbnuts", "nutsack", "orgasim", "orgasims", "orgasm", "orgasms",
"p0rn", "pawn", "pecker", "penis", "penisfucker", "phonesex", "phuck", "phuk",
"phuked", "phuking", "phukked", "phukking", "phuks", "phuq", "pigfucker", "pimpis",
"piss", "pissed", "pisser", "pissers", "pisses", "pissflaps", "pissin", "pissing",
"pissoff", "poop", "porn", "porno", "pornography", "pornos", "prick", "pricks",
"pron", "pube", "pusse", "pussi", "pussies", "pussy", "pussys", "rectum", "retard",
"rimjaw", "rimming", "s hit", "s.o.b.", "sadist", "schlong", "screwing", "scroat",
"scrote", "scrotum", "semen", "sex", "sh!+", "sh!t", "sh1t", "shag", "shagger",
"shaggin", "shagging", "shemale", "shi+", "shit", "shitdick", "shite", "shited",
"shitey", "shitfuck", "shitfull", "shithead", "shiting", "shitings", "shits",
"shitted", "shitter", "shitters", "shitting", "shittings", "shitty", "skank",
"slut", "sluts", "smegma", "smut", "snatch", "son-of-a-bitch", "spac", "spunk",
"s_h_i_t", "t1tt1e5", "t1tties", "teets", "teez", "testical", "testicle", "tit",
"titfuck", "tits", "titt", "tittie5", "tittiefucker", "titties", "tittyfuck",
"tittywank", "titwank", "tosser", "turd", "tw4t", "twat", "twathead", "twatty",
"twunt", "twunter", "v14gra", "v1gra", "vagina", "viagra", "vulva", "w00se",
"wang", "wank", "wanker", "wanky", "whoar", "whore", "willies", "willy", "xrated",
"xxx"];

/***/ }),

[Link] = {
object: __webpack_require__(/*! ./object */ "./node_modules/badwords-
list/lib/[Link]"),
array: __webpack_require__(/*! ./array */ "./node_modules/badwords-
list/lib/[Link]"),
regex: __webpack_require__(/*! ./regexp */ "./node_modules/badwords-
list/lib/[Link]")
};

/***/ }),

/***/ "./node_modules/badwords-list/lib/[Link]":
/*!**************************************************!*\
!*** ./node_modules/badwords-list/lib/[Link] ***!
\**************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

[Link] = {"4r5e": 1, "5h1t": 1, "5hit": 1, "a55": 1, "anal": 1,

"anus": 1, "ar5e": 1, "arrse": 1, "arse": 1, "ass": 1, "ass-fucker": 1, "asses": 1,
"assfucker": 1, "assfukka": 1, "asshole": 1, "assholes": 1, "asswhole": 1, "a_s_s":
1, "b!tch": 1, "b00bs": 1, "b17ch": 1, "b1tch": 1, "ballbag": 1, "balls": 1,
"ballsack": 1, "bastard": 1, "beastial": 1, "beastiality": 1, "bellend": 1,
"bestial": 1, "bestiality": 1, "bi+ch": 1, "biatch": 1, "bitch": 1, "bitcher": 1,
"bitchers": 1, "bitches": 1, "bitchin": 1, "bitching": 1, "bloody": 1, "blow job":
1, "blowjob": 1, "blowjobs": 1, "boiolas": 1, "bollock": 1, "bollok": 1, "boner":
1, "boob": 1, "boobs": 1, "booobs": 1, "boooobs": 1, "booooobs": 1, "booooooobs":
1, "breasts": 1, "buceta": 1, "bugger": 1, "bum": 1, "bunny fucker": 1, "butt": 1,
"butthole": 1, "buttmuch": 1, "buttplug": 1, "c0ck": 1, "c0cksucker": 1, "carpet
muncher": 1, "cawk": 1, "chink": 1, "cipa": 1, "cl1t": 1, "clit": 1, "clitoris": 1,
"clits": 1, "cnut": 1, "cock": 1, "cock-sucker": 1, "cockface": 1, "cockhead": 1,
"cockmunch": 1, "cockmuncher": 1, "cocks": 1, "cocksuck": 1, "cocksucked": 1,
"cocksucker": 1, "cocksucking": 1, "cocksucks": 1, "cocksuka": 1, "cocksukka": 1,
"cok": 1, "cokmuncher": 1, "coksucka": 1, "coon": 1, "cox": 1, "crap": 1, "cum": 1,
"cummer": 1, "cumming": 1, "cums": 1, "cumshot": 1, "cunilingus": 1, "cunillingus":
1, "cunnilingus": 1, "cunt": 1, "cuntlick": 1, "cuntlicker": 1, "cuntlicking": 1,
"cunts": 1, "cyalis": 1, "cyberfuc": 1, "cyberfuck": 1, "cyberfucked": 1,
"cyberfucker": 1, "cyberfuckers": 1, "cyberfucking": 1, "d1ck": 1, "damn": 1,
"dick": 1, "dickhead": 1, "dildo": 1, "dildos": 1, "dink": 1, "dinks": 1, "dirsa":
1, "dlck": 1, "dog-fucker": 1, "doggin": 1, "dogging": 1, "donkeyribber": 1,
"doosh": 1, "duche": 1, "dyke": 1, "ejaculate": 1, "ejaculated": 1, "ejaculates":
1, "ejaculating": 1, "ejaculatings": 1, "ejaculation": 1, "ejakulate": 1, "f u c
k": 1, "f u c k e r": 1, "f4nny": 1, "fag": 1, "fagging": 1, "faggitt": 1,
"faggot": 1, "faggs": 1, "fagot": 1, "fagots": 1, "fags": 1, "fanny": 1,
"fannyflaps": 1, "fannyfucker": 1, "fanyy": 1, "fatass": 1, "fcuk": 1, "fcuker": 1,
"fcuking": 1, "feck": 1, "fecker": 1, "felching": 1, "fellate": 1, "fellatio": 1,
"fingerfuck": 1, "fingerfucked": 1, "fingerfucker": 1, "fingerfuckers": 1,
"fingerfucking": 1, "fingerfucks": 1, "fistfuck": 1, "fistfucked": 1, "fistfucker":
1, "fistfuckers": 1, "fistfucking": 1, "fistfuckings": 1, "fistfucks": 1, "flange":
1, "fook": 1, "fooker": 1, "fuck": 1, "fucka": 1, "fucked": 1, "fucker": 1,
"fuckers": 1, "fuckhead": 1, "fuckheads": 1, "fuckin": 1, "fucking": 1, "fuckings":
1, "fuckingshitmotherfucker": 1, "fuckme": 1, "fucks": 1, "fuckwhit": 1, "fuckwit":
1, "fudge packer": 1, "fudgepacker": 1, "fuk": 1, "fuker": 1, "fukker": 1,
"fukkin": 1, "fuks": 1, "fukwhit": 1, "fukwit": 1, "fux": 1, "fux0r": 1, "f_u_c_k":
1, "gangbang": 1, "gangbanged": 1, "gangbangs": 1, "gaylord": 1, "gaysex": 1,
"goatse": 1, "God": 1, "god-dam": 1, "god-damned": 1, "goddamn": 1, "goddamned": 1,
"hardcoresex": 1, "hell": 1, "heshe": 1, "hoar": 1, "hoare": 1, "hoer": 1, "homo":
1, "hore": 1, "horniest": 1, "horny": 1, "hotsex": 1, "jack-off": 1, "jackoff": 1,
"jap": 1, "jerk-off": 1, "jism": 1, "jiz": 1, "jizm": 1, "jizz": 1, "kawk": 1,
"knob": 1, "knobead": 1, "knobed": 1, "knobend": 1, "knobhead": 1, "knobjocky": 1,
"knobjokey": 1, "kock": 1, "kondum": 1, "kondums": 1, "kum": 1, "kummer": 1,
"kumming": 1, "kums": 1, "kunilingus": 1, "l3i+ch": 1, "l3itch": 1, "labia": 1,
"lust": 1, "lusting": 1, "m0f0": 1, "m0fo": 1, "m45terbate": 1, "ma5terb8": 1,
"ma5terbate": 1, "masochist": 1, "master-bate": 1, "masterb8": 1, "masterbat*": 1,
"masterbat3": 1, "masterbate": 1, "masterbation": 1, "masterbations": 1,
"masturbate": 1, "mo-fo": 1, "mof0": 1, "mofo": 1, "mothafuck": 1, "mothafucka": 1,
"mothafuckas": 1, "mothafuckaz": 1, "mothafucked": 1, "mothafucker": 1,
"mothafuckers": 1, "mothafuckin": 1, "mothafucking": 1, "mothafuckings": 1,
"mothafucks": 1, "mother fucker": 1, "motherfuck": 1, "motherfucked": 1,
"motherfucker": 1, "motherfuckers": 1, "motherfuckin": 1, "motherfucking": 1,
"motherfuckings": 1, "motherfuckka": 1, "motherfucks": 1, "muff": 1, "mutha": 1,
"muthafecker": 1, "muthafuckker": 1, "muther": 1, "mutherfucker": 1, "n1gga": 1,
"n1gger": 1, "nazi": 1, "nigg3r": 1, "nigg4h": 1, "nigga": 1, "niggah": 1,
"niggas": 1, "niggaz": 1, "nigger": 1, "niggers": 1, "nob": 1, "nob jokey": 1,
"nobhead": 1, "nobjocky": 1, "nobjokey": 1, "numbnuts": 1, "nutsack": 1, "orgasim":
1, "orgasims": 1, "orgasm": 1, "orgasms": 1, "p0rn": 1, "pawn": 1, "pecker": 1,
"penis": 1, "penisfucker": 1, "phonesex": 1, "phuck": 1, "phuk": 1, "phuked": 1,
"phuking": 1, "phukked": 1, "phukking": 1, "phuks": 1, "phuq": 1, "pigfucker": 1,
"pimpis": 1, "piss": 1, "pissed": 1, "pisser": 1, "pissers": 1, "pisses": 1,
"pissflaps": 1, "pissin": 1, "pissing": 1, "pissoff": 1, "poop": 1, "porn": 1,
"porno": 1, "pornography": 1, "pornos": 1, "prick": 1, "pricks": 1, "pron": 1,
"pube": 1, "pusse": 1, "pussi": 1, "pussies": 1, "pussy": 1, "pussys": 1, "rectum":
1, "retard": 1, "rimjaw": 1, "rimming": 1, "s hit": 1, "s.o.b.": 1, "sadist": 1,
"schlong": 1, "screwing": 1, "scroat": 1, "scrote": 1, "scrotum": 1, "semen": 1,
"sex": 1, "sh!+": 1, "sh!t": 1, "sh1t": 1, "shag": 1, "shagger": 1, "shaggin": 1,
"shagging": 1, "shemale": 1, "shi+": 1, "shit": 1, "shitdick": 1, "shite": 1,
"shited": 1, "shitey": 1, "shitfuck": 1, "shitfull": 1, "shithead": 1, "shiting":
1, "shitings": 1, "shits": 1, "shitted": 1, "shitter": 1, "shitters": 1,
"shitting": 1, "shittings": 1, "shitty": 1, "skank": 1, "slut": 1, "sluts": 1,
"smegma": 1, "smut": 1, "snatch": 1, "son-of-a-bitch": 1, "spac": 1, "spunk": 1,
"s_h_i_t": 1, "t1tt1e5": 1, "t1tties": 1, "teets": 1, "teez": 1, "testical": 1,
"testicle": 1, "tit": 1, "titfuck": 1, "tits": 1, "titt": 1, "tittie5": 1,
"tittiefucker": 1, "titties": 1, "tittyfuck": 1, "tittywank": 1, "titwank": 1,
"tosser": 1, "turd": 1, "tw4t": 1, "twat": 1, "twathead": 1, "twatty": 1, "twunt":
1, "twunter": 1, "v14gra": 1, "v1gra": 1, "vagina": 1, "viagra": 1, "vulva": 1,
"w00se": 1, "wang": 1, "wank": 1, "wanker": 1, "wanky": 1, "whoar": 1, "whore": 1,
"willies": 1, "willy": 1, "xrated": 1, "xxx": 1};

/***/ }),

/***/ }),

/***/ "./node_modules/base64-js/[Link]":
/*!*****************************************!*\
!*** ./node_modules/base64-js/[Link] ***!
\*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

[Link] = byteLength
[Link] = toByteArray
[Link] = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

var code =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = [Link]; i < len; ++i) {
lookup[i] = code[i]
revLookup[[Link](i)] = i
}

// Support decoding URL-safe base64 strings, as [Link] does.

// See: [Link]
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63

function getLens (b64) {

var len = [Link]

if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}

// Trim off extra bytes after placeholder bytes are found

// See: [Link]
var validLen = [Link]('=')
if (validLen === -1) validLen = len

var placeHoldersLen = validLen === len

? 0
: 4 - (validLen % 4)

return [validLen, placeHoldersLen]

}
// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function _byteLength (b64, validLen, placeHoldersLen) {

return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function toByteArray (b64) {

var tmp
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]

var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

var curByte = 0

// if there are placeholders, only get up to the last complete 4 chars

var len = placeHoldersLen > 0
? validLen - 4
: validLen

var i
for (i = 0; i < len; i += 4) {
tmp =
(revLookup[[Link](i)] << 18) |
(revLookup[[Link](i + 1)] << 12) |
(revLookup[[Link](i + 2)] << 6) |
revLookup[[Link](i + 3)]
arr[curByte++] = (tmp >> 16) & 0xFF
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}

if (placeHoldersLen === 2) {
tmp =
(revLookup[[Link](i)] << 2) |
(revLookup[[Link](i + 1)] >> 4)
arr[curByte++] = tmp & 0xFF
}

if (placeHoldersLen === 1) {
tmp =
(revLookup[[Link](i)] << 10) |
(revLookup[[Link](i + 1)] << 4) |
(revLookup[[Link](i + 2)] >> 2)
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}

return arr
}

function tripletToBase64 (num) {

return lookup[num >> 18 & 0x3F] +
lookup[num >> 12 & 0x3F] +
lookup[num >> 6 & 0x3F] +
lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {

var tmp
var output = []
for (var i = start; i < end; i += 3) {
tmp =
((uint8[i] << 16) & 0xFF0000) +
((uint8[i + 1] << 8) & 0xFF00) +
(uint8[i + 2] & 0xFF)
[Link](tripletToBase64(tmp))
}
return [Link]('')
}

function fromByteArray (uint8) {

var tmp
var len = [Link]
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
var parts = []
var maxChunkLength = 16383 // must be multiple of 3

// go through the array every three bytes, we'll deal with trailing
stuff later
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength)
{
[Link](encodeChunk(
uint8, i, (i + maxChunkLength) > len2 ? len2 : (i +
maxChunkLength)
))
}

// pad the end with zeros, but make sure to not forget the extra bytes
if (extraBytes === 1) {
tmp = uint8[len - 1]
[Link](
lookup[tmp >> 2] +
lookup[(tmp << 4) & 0x3F] +
'=='
)
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
[Link](
lookup[tmp >> 10] +
lookup[(tmp >> 4) & 0x3F] +
lookup[(tmp << 2) & 0x3F] +
'='
)
}

return [Link]('')
}

/***/ }),
/***/ "./node_modules/buffer/[Link]":
/*!**************************************!*\
!*** ./node_modules/buffer/[Link] ***!
\**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/*!
* The buffer module from [Link], for the browser.
*
* @author Feross Aboukhadijeh <[Link]
* @license MIT
*/
/* eslint-disable no-proto */

var base64 = __webpack_require__(/! base64-js /

"./node_modules/base64-js/[Link]")
var ieee754 = __webpack_require__(/*! ieee754 */
"./node_modules/ieee754/[Link]")
var isArray = __webpack_require__(/*! isarray */
"./node_modules/buffer/node_modules/isarray/[Link]")

[Link] = Buffer
[Link] = SlowBuffer
exports.INSPECT_MAX_BYTES = 50

/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari
5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Due to various browser bugs, sometimes the Object implementation will be used
even
* when the browser supports typed arrays.
*
* Note:
*
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array`
instances,
* See: [Link]
*
* - Chrome 9-10 is missing the `[Link]` function.
*
* - IE10 has a broken `[Link]` function which returns
arrays of
* incorrect length in some situations.

* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false`

so they
* get the Object implementation, which is slower but behaves correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
? global.TYPED_ARRAY_SUPPORT
: typedArraySupport()

/*
* Export kMaxLength after typed array support is determined.
*/
[Link] = kMaxLength()

function typedArraySupport () {
try {
var arr = new Uint8Array(1)
arr.__proto__ = {__proto__: [Link], foo: function
() { return 42 }}
return [Link]() === 42 && // typed array instances can be
augmented
typeof [Link] === 'function' && // chrome 9-10 lack
`subarray`
[Link](1, 1).byteLength === 0 // ie10 has broken
`subarray`
} catch (e) {
return false
}
}

function kMaxLength () {
return Buffer.TYPED_ARRAY_SUPPORT
? 0x7fffffff
: 0x3fffffff
}

function createBuffer (that, length) {

if (kMaxLength() < length) {
throw new RangeError('Invalid typed array length')
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best
performance
that = new Uint8Array(length)
that.__proto__ = [Link]
} else {
// Fallback: Return an object instance of the Buffer class
if (that === null) {
that = new Buffer(length)
}
[Link] = length
}

return that
}

/**
* The Buffer constructor returns instances of Ùint8Array` that have their
* prototype changed to `[Link]`. Furthermore, `Buffer` is a subclass of
* Ùint8Array`, so the returned instances will have all the node `Buffer` methods
* and the Ùint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The Ùint8Array` prototype remains unmodified.
*/

function Buffer (arg, encodingOrOffset, length) {

if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
return new Buffer(arg, encodingOrOffset, length)
}

// Common case.
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new Error(
'If encoding is specified then the first argument must
be a string'
)
}
return allocUnsafe(this, arg)
}
return from(this, arg, encodingOrOffset, length)
}

[Link] = 8192 // not used by this implementation

// TODO: Legacy, not needed anymore. Remove in next major version.

Buffer._augment = function (arr) {
arr.__proto__ = [Link]
return arr
}

function from (that, value, encodingOrOffset, length) {

if (typeof value === 'number') {
throw new TypeError('"value" argument must not be a number')
}

if (typeof ArrayBuffer !== 'undefined' && value instanceof

ArrayBuffer) {
return fromArrayBuffer(that, value, encodingOrOffset, length)
}

if (typeof value === 'string') {

return fromString(that, value, encodingOrOffset)
}

return fromObject(that, value)

}

/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* [Link](str[, encoding])
* [Link](array)
* [Link](buffer)
* [Link](arrayBuffer[, byteOffset[, length]])
**/
[Link] = function (value, encodingOrOffset, length) {
return from(null, value, encodingOrOffset, length)
}

if (Buffer.TYPED_ARRAY_SUPPORT) {
[Link].__proto__ = [Link]
Buffer.__proto__ = Uint8Array
if (typeof Symbol !== 'undefined' && [Link] &&
Buffer[[Link]] === Buffer) {
// Fix subarray() in ES2016. See:
[Link]
[Link](Buffer, [Link], {
value: null,
configurable: true
})
}
}

function assertSize (size) {

if (typeof size !== 'number') {
throw new TypeError('"size" argument must be a number')
} else if (size < 0) {
throw new RangeError('"size" argument must not be negative')
}
}

function alloc (that, size, fill, encoding) {

assertSize(size)
if (size <= 0) {
return createBuffer(that, size)
}
if (fill !== undefined) {
// Only pay attention to encoding if it's a string. This
// prevents accidentally sending in a number that would
// be interpretted as a start offset.
return typeof encoding === 'string'
? createBuffer(that, size).fill(fill, encoding)
: createBuffer(that, size).fill(fill)
}
return createBuffer(that, size)
}

/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
[Link] = function (size, fill, encoding) {
return alloc(null, size, fill, encoding)
}

function allocUnsafe (that, size) {

assertSize(size)
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < size; ++i) {
that[i] = 0
}
}
return that
}

/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
[Link] = function (size) {
return allocUnsafe(null, size)
}
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer
instance.
*/
[Link] = function (size) {
return allocUnsafe(null, size)
}

function fromString (that, string, encoding) {

if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8'
}

if (![Link](encoding)) {
throw new TypeError('"encoding" must be a valid string
encoding')
}

var length = byteLength(string, encoding) | 0

that = createBuffer(that, length)

var actual = [Link](string, encoding)

if (actual !== length) {

// Writing a hex string, for example, that contains invalid
characters will
// cause everything after the first invalid character to be
ignored. (e.g.
// 'abxxcd' will be treated as 'ab')
that = [Link](0, actual)
}

return that
}

function fromArrayLike (that, array) {

var length = [Link] < 0 ? 0 : checked([Link]) | 0
that = createBuffer(that, length)
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}

function fromArrayBuffer (that, array, byteOffset, length) {

[Link] // this throws if `array` is not a valid
ArrayBuffer

if (byteOffset < 0 || [Link] < byteOffset) {

throw new RangeError('\'offset\' is out of bounds')
}

if ([Link] < byteOffset + (length || 0)) {

throw new RangeError('\'length\' is out of bounds')
}

if (byteOffset === undefined && length === undefined) {

array = new Uint8Array(array)
} else if (length === undefined) {
array = new Uint8Array(array, byteOffset)
} else {
array = new Uint8Array(array, byteOffset, length)
}

if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best
performance
that = array
that.__proto__ = [Link]
} else {
// Fallback: Return an object instance of the Buffer class
that = fromArrayLike(that, array)
}
return that
}

function fromObject (that, obj) {

if ([Link](obj)) {
var len = checked([Link]) | 0
that = createBuffer(that, len)

if ([Link] === 0) {
return that
}

[Link](that, 0, 0, len)
return that
}

if (obj) {
if ((typeof ArrayBuffer !== 'undefined' &&
[Link] instanceof ArrayBuffer) || 'length' in obj) {
if (typeof [Link] !== 'number' || isnan([Link])) {
return createBuffer(that, 0)
}
return fromArrayLike(that, obj)
}

if ([Link] === 'Buffer' && isArray([Link])) {

return fromArrayLike(that, [Link])
}
}

throw new TypeError('First argument must be a string, Buffer,

ArrayBuffer, Array, or array-like object.')
}

function checked (length) {

// Note: cannot use `length < kMaxLength()` here because that fails
when
// length is NaN (which is otherwise coerced to zero.)
if (length >= kMaxLength()) {
throw new RangeError('Attempt to allocate Buffer larger than
maximum ' +
'size: 0x' + kMaxLength().toString(16) + '
bytes')
}
return length | 0
}

function SlowBuffer (length) {

if (+length != length) { // eslint-disable-line eqeqeq
length = 0
}
return [Link](+length)
}

[Link] = function isBuffer (b) {

return !!(b != null && b._isBuffer)
}

[Link] = function compare (a, b) {

if (![Link](a) || ![Link](b)) {
throw new TypeError('Arguments must be Buffers')
}

if (a === b) return 0

var x = [Link]
var y = [Link]

for (var i = 0, len = [Link](x, y); i < len; ++i) {

if (a[i] !== b[i]) {
x = a[i]
y = b[i]
break
}
}

if (x < y) return -1
if (y < x) return 1
return 0
}

[Link] = function concat (list, length) {

if (!isArray(list)) {
throw new TypeError('"list" argument must be an Array of
Buffers')
}

if ([Link] === 0) {
return [Link](0)
}

var i
if (length === undefined) {
length = 0
for (i = 0; i < [Link]; ++i) {
length += list[i].length
}
}

function byteLength (string, encoding) {

if ([Link](string)) {
return [Link]
}
if (typeof ArrayBuffer !== 'undefined' && typeof [Link]
=== 'function' &&
([Link](string) || string instanceof ArrayBuffer))
{
return [Link]
}
if (typeof string !== 'string') {
string = '' + string
}

var len = [Link]

if (len === 0) return 0

// Use a for loop to avoid recursion

var loweredCase = false
for (;;) {
switch (encoding) {
case 'ascii':
case 'latin1':
case 'binary':
return len
case 'utf8':
case 'utf-8':
case undefined:
return utf8ToBytes(string).length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return len * 2
case 'hex':
return len >>> 1
case 'base64':
return base64ToBytes(string).length
default:
if (loweredCase) return utf8ToBytes(string).length //
assume utf8
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
[Link] = byteLength

function slowToString (encoding, start, end) {

var loweredCase = false

// No need to verify that "[Link] <= MAX_UINT32" since it's a

read-only
// property of a typed array.

// This behaves neither like String nor Uint8Array in that we set

start/end
// to their upper/lower bounds if the value passed is out of range.
// undefined is handled specially as per ECMA-262 6th Edition,
// Section [Link] Runtime Semantics: KeyedBindingInitialization.
if (start === undefined || start < 0) {
start = 0
}
// Return early if start > [Link]. Done here to prevent
potential uint32
// coercion fail below.
if (start > [Link]) {
return ''
}

if (end === undefined || end > [Link]) {

end = [Link]
}

if (end <= 0) {
return ''
}

// Force coersion to uint32. This will also coerce falsey/NaN

values to 0.
end >>>= 0
start >>>= 0

if (end <= start) {

return ''
}

if (!encoding) encoding = 'utf8'

while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)

case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)

case 'ascii':
return asciiSlice(this, start, end)

case 'latin1':
case 'binary':
return latin1Slice(this, start, end)

case 'base64':
return base64Slice(this, start, end)

case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)

default:
if (loweredCase) throw new TypeError('Unknown encoding:
' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}

// The property is used by `[Link]` and `is-buffer` (in Safari

5-7) to detect
// Buffer instances.
[Link]._isBuffer = true

function swap (b, n, m) {

var i = b[n]
b[n] = b[m]
b[m] = i
}

[Link] = function toString () {

var length = [Link] | 0
if (length === 0) return ''
if ([Link] === 0) return utf8Slice(this, 0, length)
return [Link](this, arguments)
}

[Link] = function equals (b) {

if (![Link](b)) throw new TypeError('Argument must be a
Buffer')
if (this === b) return true
return [Link](this, b) === 0
}

[Link] = function compare (target, start, end,

thisStart, thisEnd) {
if (![Link](target)) {
throw new TypeError('Argument must be a Buffer')
}

if (start === undefined) {

start = 0
}
if (end === undefined) {
end = target ? [Link] : 0
}
if (thisStart === undefined) {
thisStart = 0
}
if (thisEnd === undefined) {
thisEnd = [Link]
}

if (start < 0 || end > [Link] || thisStart < 0 || thisEnd >

[Link]) {
throw new RangeError('out of range index')
}

if (thisStart >= thisEnd && start >= end) {

return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}

start >>>= 0
end >>>= 0
thisStart >>>= 0
thisEnd >>>= 0

if (this === target) return 0

var x = thisEnd - thisStart

var y = end - start
var len = [Link](x, y)

var thisCopy = [Link](thisStart, thisEnd)

var targetCopy = [Link](start, end)

for (var i = 0; i < len; ++i) {

if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i]
y = targetCopy[i]
break
}
}

if (x < y) return -1
if (y < x) return 1
return 0
}

// Finds either the first index of `val` in `buffer` at offset >=

`byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir)
{
// Empty buffer means no match
if ([Link] === 0) return -1

// Normalize byteOffset
if (typeof byteOffset === 'string') {
encoding = byteOffset
byteOffset = 0
} else if (byteOffset > 0x7fffffff) {
byteOffset = 0x7fffffff
} else if (byteOffset < -0x80000000) {
byteOffset = -0x80000000
}
byteOffset = +byteOffset // Coerce to Number.
if (isNaN(byteOffset)) {
// byteOffset: it it's undefined, null, NaN, "foo", etc, search
whole buffer
byteOffset = dir ? 0 : ([Link] - 1)
}

// Normalize byteOffset: negative offsets start from the end of the

buffer
if (byteOffset < 0) byteOffset = [Link] + byteOffset
if (byteOffset >= [Link]) {
if (dir) return -1
else byteOffset = [Link] - 1
} else if (byteOffset < 0) {
if (dir) byteOffset = 0
else return -1
}

// Normalize val
if (typeof val === 'string') {
val = [Link](val, encoding)
}

// Finally, search either indexOf (if dir is true) or lastIndexOf

if ([Link](val)) {
// Special case: looking for empty string/buffer always fails
if ([Link] === 0) {
return -1
}
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
} else if (typeof val === 'number') {
val = val & 0xFF // Search for a byte value [0-255]
if (Buffer.TYPED_ARRAY_SUPPORT &&
typeof [Link] === 'function') {
if (dir) {
return [Link](buffer, val,
byteOffset)
} else {
return [Link](buffer,
val, byteOffset)
}
}
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}

throw new TypeError('val must be string, number or Buffer')

}

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {

var indexSize = 1
var arrLength = [Link]
var valLength = [Link]

if (encoding !== undefined) {

encoding = String(encoding).toLowerCase()
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if ([Link] < 2 || [Link] < 2) {
return -1
}
indexSize = 2
arrLength /= 2
valLength /= 2
byteOffset /= 2
}
}

function read (buf, i) {

if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}

var i
if (dir) {
var foundIndex = -1
for (i = byteOffset; i < arrLength; i++) {
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i -
foundIndex)) {
if (foundIndex === -1) foundIndex = i
if (i - foundIndex + 1 === valLength) return foundIndex
* indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex
foundIndex = -1
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength
- valLength
for (i = byteOffset; i >= 0; i--) {
var found = true
for (var j = 0; j < valLength; j++) {
if (read(arr, i + j) !== read(val, j)) {
found = false
break
}
}
if (found) return i
}
}

return -1
}

[Link] = function includes (val, byteOffset,

encoding) {
return [Link](val, byteOffset, encoding) !== -1
}

[Link] = function indexOf (val, byteOffset, encoding)

{
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

[Link] = function lastIndexOf (val, byteOffset,

encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

function hexWrite (buf, string, offset, length) {

offset = Number(offset) || 0
var remaining = [Link] - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}

// must be an even number of digits

var strLen = [Link]
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

if (length > strLen / 2) {

length = strLen / 2
}
for (var i = 0; i < length; ++i) {
var parsed = parseInt([Link](i * 2, 2), 16)
if (isNaN(parsed)) return i
buf[offset + i] = parsed
}
return i
}

function utf8Write (buf, string, offset, length) {

return blitBuffer(utf8ToBytes(string, [Link] - offset), buf,
offset, length)
}

function asciiWrite (buf, string, offset, length) {

return blitBuffer(asciiToBytes(string), buf, offset, length)
}

function latin1Write (buf, string, offset, length) {

return asciiWrite(buf, string, offset, length)
}

function base64Write (buf, string, offset, length) {

return blitBuffer(base64ToBytes(string), buf, offset, length)
}

function ucs2Write (buf, string, offset, length) {

return blitBuffer(utf16leToBytes(string, [Link] - offset), buf,
offset, length)
}

var remaining = [Link] - offset

if (length === undefined || length > remaining) length = remaining

if (([Link] > 0 && (length < 0 || offset < 0)) || offset >
[Link]) {
throw new RangeError('Attempt to write outside buffer bounds')
}

if (!encoding) encoding = 'utf8'

var loweredCase = false

for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)

case 'ascii':
return asciiWrite(this, string, offset, length)

case 'latin1':
case 'binary':
return latin1Write(this, string, offset, length)

case 'base64':
// Warning: maxLength not taken into account in
base64Write
return base64Write(this, string, offset, length)

case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)

default:
if (loweredCase) throw new TypeError('Unknown encoding:
' + encoding)
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}

[Link] = function toJSON () {

return {
type: 'Buffer',
data: [Link](this._arr || this, 0)
}
}

function base64Slice (buf, start, end) {

if (start === 0 && end === [Link]) {
return [Link](buf)
} else {
return [Link]([Link](start, end))
}
}

function utf8Slice (buf, start, end) {

end = [Link]([Link], end)
var res = []

var i = start
while (i < end) {
var firstByte = buf[i]
var codePoint = null
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint

switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte
}
break
case 2:
secondByte = buf[i + 1]
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 |
(secondByte & 0x3F)
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint
}
}
break
case 3:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
if ((secondByte & 0xC0) === 0x80 && (thirdByte &
0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC |
(secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
if (tempCodePoint > 0x7FF && (tempCodePoint <
0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint
}
}
break
case 4:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
fourthByte = buf[i + 3]
if ((secondByte & 0xC0) === 0x80 && (thirdByte &
0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 |
(secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
if (tempCodePoint > 0xFFFF && tempCodePoint <
0x110000) {
codePoint = tempCodePoint
}
}
}
}

if (codePoint === null) {

// we did not generate a valid codePoint so insert a
// replacement char (U+FFFD) and advance only 1 byte
codePoint = 0xFFFD
bytesPerSequence = 1
} else if (codePoint > 0xFFFF) {
// encode to utf16 (surrogate pair dance)
codePoint -= 0x10000
[Link](codePoint >>> 10 & 0x3FF | 0xD800)
codePoint = 0xDC00 | codePoint & 0x3FF
}
[Link](codePoint)
i += bytesPerSequence
}

return decodeCodePointsArray(res)
}

// Based on [Link] the browser

with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000

function decodeCodePointsArray (codePoints) {

var len = [Link]
if (len <= MAX_ARGUMENTS_LENGTH) {
return [Link](String, codePoints) // avoid
extra slice()
}

// Decode in chunks to avoid "call stack size exceeded".

var res = ''
var i = 0
while (i < len) {
res += [Link](
String,
[Link](i, i += MAX_ARGUMENTS_LENGTH)
)
}
return res
}

function asciiSlice (buf, start, end) {

var ret = ''
end = [Link]([Link], end)

for (var i = start; i < end; ++i) {

ret += [Link](buf[i] & 0x7F)
}
return ret
}

function latin1Slice (buf, start, end) {

var ret = ''
end = [Link]([Link], end)

for (var i = start; i < end; ++i) {

ret += [Link](buf[i])
}
return ret
}

function hexSlice (buf, start, end) {

var len = [Link]

if (!start || start < 0) start = 0

if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; ++i) {
out += toHex(buf[i])
}
return out
}

function utf16leSlice (buf, start, end) {

var bytes = [Link](start, end)
var res = ''
for (var i = 0; i < [Link]; i += 2) {
res += [Link](bytes[i] + bytes[i + 1] * 256)
}
return res
}

[Link] = function slice (start, end) {

var len = [Link]
start = ~~start
end = end === undefined ? len : ~~end

if (start < 0) {
start += len
if (start < 0) start = 0
} else if (start > len) {
start = len
}

if (end < 0) {
end += len
if (end < 0) end = 0
} else if (end > len) {
end = len
}

if (end < start) end = start

var newBuf
if (Buffer.TYPED_ARRAY_SUPPORT) {
newBuf = [Link](start, end)
newBuf.__proto__ = [Link]
} else {
var sliceLen = end - start
newBuf = new Buffer(sliceLen, undefined)
for (var i = 0; i < sliceLen; ++i) {
newBuf[i] = this[i + start]
}
}

return newBuf
}

/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset
is not uint')
if (offset + ext > length) throw new RangeError('Trying to access
beyond buffer length')
}

[Link] = function readUIntLE (offset, byteLength,

noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, [Link])

var val = this[offset]

var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}

return val
}

[Link] = function readUIntBE (offset, byteLength,

noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) {
checkOffset(offset, byteLength, [Link])
}

var val = this[offset + --byteLength]

var mul = 1
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul
}

return val
}

[Link].readUInt8 = function readUInt8 (offset, noAssert) {

if (!noAssert) checkOffset(offset, 1, [Link])
return this[offset]
}

[Link].readUInt16LE = function readUInt16LE (offset,

noAssert) {
if (!noAssert) checkOffset(offset, 2, [Link])
return this[offset] | (this[offset + 1] << 8)
}

[Link].readUInt16BE = function readUInt16BE (offset,

noAssert) {
if (!noAssert) checkOffset(offset, 2, [Link])
return (this[offset] << 8) | this[offset + 1]
}

[Link].readUInt32LE = function readUInt32LE (offset,

noAssert) {
if (!noAssert) checkOffset(offset, 4, [Link])

return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}

[Link].readUInt32BE = function readUInt32BE (offset,

noAssert) {
if (!noAssert) checkOffset(offset, 4, [Link])

return (this[offset] * 0x1000000) +

((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}

[Link] = function readIntLE (offset, byteLength,

noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, [Link])

var val = this[offset]

var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
mul *= 0x80

if (val >= mul) val -= [Link](2, 8 * byteLength)

return val
}

[Link] = function readIntBE (offset, byteLength,

noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, [Link])

var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul
}
mul *= 0x80

if (val >= mul) val -= [Link](2, 8 * byteLength)

return val
}

[Link].readInt8 = function readInt8 (offset, noAssert) {

if (!noAssert) checkOffset(offset, 1, [Link])
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}

[Link].readInt16LE = function readInt16LE (offset, noAssert)

{
if (!noAssert) checkOffset(offset, 2, [Link])
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}

[Link].readInt16BE = function readInt16BE (offset, noAssert)

{
if (!noAssert) checkOffset(offset, 2, [Link])
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}

[Link].readInt32LE = function readInt32LE (offset, noAssert)

{
if (!noAssert) checkOffset(offset, 4, [Link])

return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}

[Link].readInt32BE = function readInt32BE (offset, noAssert)

{
if (!noAssert) checkOffset(offset, 4, [Link])

return (this[offset] << 24) |

(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}

[Link] = function readFloatLE (offset, noAssert)

{
if (!noAssert) checkOffset(offset, 4, [Link])
return [Link](this, offset, true, 23, 4)
}

[Link] = function readFloatBE (offset, noAssert)

{
if (!noAssert) checkOffset(offset, 4, [Link])
return [Link](this, offset, false, 23, 4)
}

[Link] = function readDoubleLE (offset,

noAssert) {
if (!noAssert) checkOffset(offset, 8, [Link])
return [Link](this, offset, true, 52, 8)
}

[Link] = function readDoubleBE (offset,

noAssert) {
if (!noAssert) checkOffset(offset, 8, [Link])
return [Link](this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {

if (![Link](buf)) throw new TypeError('"buffer" argument
must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value"
argument is out of bounds')
if (offset + ext > [Link]) throw new RangeError('Index out of
range')
}

[Link] = function writeUIntLE (value, offset,

byteLength, noAssert) {
value = +value
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) {
var maxBytes = [Link](2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}

var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}

return offset + byteLength

}

[Link] = function writeUIntBE (value, offset,

var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}

return offset + byteLength

}

[Link].writeUInt8 = function writeUInt8 (value, offset,

noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = [Link](value)
this[offset] = (value & 0xff)
return offset + 1
}

function objectWriteUInt16 (buf, value, offset, littleEndian) {

if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = [Link]([Link] - offset, 2); i < j; ++i) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1
- i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}

[Link].writeUInt16LE = function writeUInt16LE (value, offset,

noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
} else {
objectWriteUInt16(this, value, offset, true)
}
return offset + 2
}

[Link].writeUInt16BE = function writeUInt16BE (value, offset,

noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
} else {
objectWriteUInt16(this, value, offset, false)
}
return offset + 2
}

function objectWriteUInt32 (buf, value, offset, littleEndian) {

if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = [Link]([Link] - offset, 4); i < j; ++i) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) &
0xff
}
}

[Link].writeUInt32LE = function writeUInt32LE (value, offset,

noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = (value & 0xff)
} else {
objectWriteUInt32(this, value, offset, true)
}
return offset + 4
}
[Link].writeUInt32BE = function writeUInt32BE (value, offset,
noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
} else {
objectWriteUInt32(this, value, offset, false)
}
return offset + 4
}

[Link] = function writeIntLE (value, offset,

byteLength, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) {
var limit = [Link](2, 8 * byteLength - 1)

checkInt(this, value, offset, byteLength, limit - 1, -limit)

}

var i = 0
var mul = 1
var sub = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}

return offset + byteLength

}

[Link] = function writeIntBE (value, offset,

byteLength, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) {
var limit = [Link](2, 8 * byteLength - 1)

checkInt(this, value, offset, byteLength, limit - 1, -limit)

}

var i = byteLength - 1
var mul = 1
var sub = 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}

return offset + byteLength

}

[Link].writeInt8 = function writeInt8 (value, offset,

noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = [Link](value)
if (value < 0) value = 0xff + value + 1
this[offset] = (value & 0xff)
return offset + 1
}

function checkIEEE754 (buf, value, offset, ext, max, min) {

if (offset + ext > [Link]) throw new RangeError('Index out of
range')
if (offset < 0) throw new RangeError('Index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {

if (!noAssert) {
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -
3.4028234663852886e+38)
}
[Link](buf, value, offset, littleEndian, 23, 4)
return offset + 4
}

[Link] = function writeFloatLE (value, offset,

noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}

[Link] = function writeFloatBE (value, offset,

noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {

if (!noAssert) {
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -
1.7976931348623157E+308)
}
[Link](buf, value, offset, littleEndian, 52, 8)
return offset + 8
}

[Link] = function writeDoubleLE (value, offset,

noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
[Link] = function writeDoubleBE (value, offset,
noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0,

sourceEnd=[Link])
[Link] = function copy (target, targetStart, start, end)
{
if (!start) start = 0
if (!end && end !== 0) end = [Link]
if (targetStart >= [Link]) targetStart = [Link]
if (!targetStart) targetStart = 0
if (end > 0 && end < start) end = start

// Copy 0 bytes; we're done

if (end === start) return 0
if ([Link] === 0 || [Link] === 0) return 0

// Fatal error conditions

if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= [Link]) throw new
RangeError('sourceStart out of bounds')
if (end < 0) throw new RangeError('sourceEnd out of bounds')

// Are we oob?
if (end > [Link]) end = [Link]
if ([Link] - targetStart < end - start) {
end = [Link] - targetStart + start
}

var len = end - start

var i

if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start]
}
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
// ascending copy from start
for (i = 0; i < len; ++i) {
target[i + targetStart] = this[i + start]
}
} else {
[Link](
target,
[Link](start, start + len),
targetStart
)
}

return len
}

// Usage:
// [Link](number[, offset[, end]])
// [Link](buffer[, offset[, end]])
// [Link](string[, offset[, end]][, encoding])
[Link] = function fill (val, start, end, encoding) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start
start = 0
end = [Link]
} else if (typeof end === 'string') {
encoding = end
end = [Link]
}
if ([Link] === 1) {
var code = [Link](0)
if (code < 256) {
val = code
}
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !
[Link](encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
} else if (typeof val === 'number') {
val = val & 255
}

// Invalid ranges are not set to a default, so can range check

early.
if (start < 0 || [Link] < start || [Link] < end) {
throw new RangeError('Out of range index')
}

if (end <= start) {

return this
}

start = start >>> 0

end = end === undefined ? [Link] : end >>> 0

if (!val) val = 0

var i
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val
}
} else {
var bytes = [Link](val)
? val
: utf8ToBytes(new Buffer(val, encoding).toString())
var len = [Link]
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len]
}
}
return this
}

// HELPER FUNCTIONS
// ================

var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g

function base64clean (str) {

// Node strips out invalid characters like \n and \t from the
string, base64-js does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if ([Link] < 2) return ''
// Node allows for non-padded base64 strings (missing trailing
===), base64-js does not
while ([Link] % 4 !== 0) {
str = str + '='
}
return str
}

function stringtrim (str) {

if ([Link]) return [Link]()
return [Link](/^\s+|\s+$/g, '')
}

function toHex (n) {

if (n < 16) return '0' + [Link](16)
return [Link](16)
}

function utf8ToBytes (string, units) {

units = units || Infinity
var codePoint
var length = [Link]
var leadSurrogate = null
var bytes = []

for (var i = 0; i < length; ++i) {

codePoint = [Link](i)

// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (!leadSurrogate) {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
continue
}

// valid lead
leadSurrogate = codePoint

continue
}

// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
}

// valid surrogate pair

codePoint = (leadSurrogate - 0xD800 << 10 | codePoint -
0xDC00) + 0x10000
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) [Link](0xEF, 0xBF, 0xBD)
}

leadSurrogate = null

// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
[Link](codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
[Link](
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
[Link](
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
[Link](
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}

return bytes
}

function asciiToBytes (str) {

var byteArray = []
for (var i = 0; i < [Link]; ++i) {
// Node's code seems to be doing this and not & 0x7F..
[Link]([Link](i) & 0xFF)
}
return byteArray
}

function utf16leToBytes (str, units) {

var c, hi, lo
var byteArray = []
for (var i = 0; i < [Link]; ++i) {
if ((units -= 2) < 0) break

c = [Link](i)
hi = c >> 8
lo = c % 256
[Link](lo)
[Link](hi)
}

return byteArray
}

function base64ToBytes (str) {

return [Link](base64clean(str))
}

function blitBuffer (src, dst, offset, length) {

for (var i = 0; i < length; ++i) {
if ((i + offset >= [Link]) || (i >= [Link])) break
dst[i + offset] = src[i]
}
return i
}

function isnan (val) {

return val !== val // eslint-disable-line no-self-compare
}

/* WEBPACK VAR INJECTION /}.call(this, __webpack_require__(/!

./../webpack/buildin/[Link] */ "./node_modules/webpack/buildin/[Link]")))

/***/ }),

/***/ "./node_modules/buffer/node_modules/isarray/[Link]":
/*!***********************************************************!*\
!*** ./node_modules/buffer/node_modules/isarray/[Link] ***!
\***********************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var toString = {}.toString;

[Link] = [Link] || function (arr) {

return [Link](arr) == '[object Array]';
};

/***/ }),

/***/ "./node_modules/charenc/[Link]":
/*!*****************************************!*\
!*** ./node_modules/charenc/[Link] ***!
\*****************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var charenc = {
// UTF-8 encoding
utf8: {
// Convert a string to a byte array
stringToBytes: function(str) {
return
[Link](unescape(encodeURIComponent(str)));
},

// Convert a byte array to a string

bytesToString: function(bytes) {
return
decodeURIComponent(escape([Link](bytes)));
}
},

// Binary encoding
bin: {
// Convert a string to a byte array
stringToBytes: function(str) {
for (var bytes = [], i = 0; i < [Link]; i++)
[Link]([Link](i) & 0xFF);
return bytes;
},

// Convert a byte array to a string

bytesToString: function(bytes) {
for (var str = [], i = 0; i < [Link]; i++)
[Link]([Link](bytes[i]));
return [Link]('');
}
}
};

[Link] = charenc;

/***/ }),

/***/ "./node_modules/crypt/[Link]":
/*!*************************************!*\
!*** ./node_modules/crypt/[Link] ***!
\*************************************/
/*! no static exports found */
/***/ (function(module, exports) {

(function() {
var base64map
= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',

crypt = {
// Bit-wise rotation left
rotl: function(n, b) {
return (n << b) | (n >>> (32 - b));
},

// Bit-wise rotation right

rotr: function(n, b) {
return (n << (32 - b)) | (n >>> b);
},

// Swap big-endian to little-endian and vice versa

endian: function(n) {
// If number given, swap endian
if ([Link] == Number) {
return [Link](n, 8) & 0x00FF00FF | [Link](n,
24) & 0xFF00FF00;
}

// Else, assume array and swap all items

for (var i = 0; i < [Link]; i++)
n[i] = [Link](n[i]);
return n;
},

// Generate an array of any length of random bytes

randomBytes: function(n) {
for (var bytes = []; n > 0; n--)
[Link]([Link]([Link]() * 256));
return bytes;
},

// Convert a byte array to big-endian 32-bit words

bytesToWords: function(bytes) {
for (var words = [], i = 0, b = 0; i < [Link]; i++, b
+= 8)
words[b >>> 5] |= bytes[i] << (24 - b % 32);
return words;
},

// Convert big-endian 32-bit words to a byte array

wordsToBytes: function(words) {
for (var bytes = [], b = 0; b < [Link] * 32; b += 8)
[Link]((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
return bytes;
},

// Convert a byte array to a hex string

bytesToHex: function(bytes) {
for (var hex = [], i = 0; i < [Link]; i++) {
[Link]((bytes[i] >>> 4).toString(16));
[Link]((bytes[i] & 0xF).toString(16));
}
return [Link]('');
},

// Convert a hex string to a byte array

hexToBytes: function(hex) {
for (var bytes = [], c = 0; c < [Link]; c += 2)
[Link](parseInt([Link](c, 2), 16));
return bytes;
},
// Convert a byte array to a base-64 string
bytesToBase64: function(bytes) {
for (var base64 = [], i = 0; i < [Link]; i += 3) {
var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) |
bytes[i + 2];
for (var j = 0; j < 4; j++)
if (i * 8 + j * 6 <= [Link] * 8)
[Link]([Link]((triplet >>> 6 *
(3 - j)) & 0x3F));
else
[Link]('=');
}
return [Link]('');
},

// Convert a base-64 string to a byte array

base64ToBytes: function(base64) {
// Remove non-base-64 characters
base64 = [Link](/[^A-Z0-9+\/]/ig, '');

[Link] = crypt;
})();

/***/ }),

/***/ "./node_modules/event-lite/[Link]":
/*!***********************************************!*\
!*** ./node_modules/event-lite/[Link] ***!
\***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/**
* [Link] - Light-weight EventEmitter (less than 1KB when gzipped)
*
* @copyright Yusuke Kawasaki
* @license MIT
* @constructor
* @see [Link]
* @see [Link]
* @example
* var EventLite = require("event-lite");
*
* function MyClass() {...} // your class
*
* [Link]([Link]); // import event methods
*
* var obj = new MyClass();
* [Link]("foo", function() {...}); // add event listener
* [Link]("bar", function() {...}); // add one-time event listener
* [Link]("foo"); // dispatch event
* [Link]("bar"); // dispatch another event
* [Link]("foo"); // remove event listener
*/

function EventLite() {
if (!(this instanceof EventLite)) return new EventLite();
}

(function(EventLite) {
// export the class for [Link]
if (true) [Link] = EventLite;

// property name to hold listeners

var LISTENERS = "listeners";

// methods to export
var methods = {
on: on,
once: once,
off: off,
emit: emit
};

// mixin to self
mixin([Link]);

// export mixin function

[Link] = mixin;

/**
* Import on(), once(), off() and emit() methods into target object.
*
* @function [Link]
* @param target {Prototype}
*/

function mixin(target) {
for (var key in methods) {
target[key] = methods[key];
}
return target;
}

/**
* Add an event listener.
*
* @function [Link]
* @param type {string}
* @param func {Function}
* @returns {EventLite} Self for method chaining
*/
function on(type, func) {
getListeners(this, type).push(func);
return this;
}

/**
* Add one-time event listener.
*
* @function [Link]
* @param type {string}
* @param func {Function}
* @returns {EventLite} Self for method chaining
*/

function once(type, func) {

var that = this;
[Link] = func;
getListeners(that, type).push(wrap);
return that;

function wrap() {
[Link](that, type, wrap);
[Link](this, arguments);
}
}

/**
* Remove an event listener.
*
* @function [Link]
* @param [type] {string}
* @param [func] {Function}
* @returns {EventLite} Self for method chaining
*/

function off(type, func) {

function ne(test) {
return test !== func && [Link] !== func;
}
}

/**
* Dispatch (trigger) an event.
*
* @function [Link]
* @param type {string}
* @param [value] {*}
* @returns {boolean} True when a listener received the event
*/

function emit(type, value) {

function zeroarg(func) {
[Link](that);
}

function onearg(func) {
[Link](that, value);
}

function moreargs(func) {
[Link](that, args);
}
}

/**
* @ignore
*/

function getListeners(that, type, readonly) {

if (readonly && !that[LISTENERS]) return;
var listeners = that[LISTENERS] || (that[LISTENERS] = {});
return listeners[type] || (listeners[type] = []);
}

})(EventLite);

/***/ }),

/***/ "./node_modules/ieee754/[Link]":
/*!***************************************!*\
!*** ./node_modules/ieee754/[Link] ***!
\***************************************/
/*! no static exports found */
/***/ (function(module, exports) {

i += d

e = s & ((1 << (-nBits)) - 1)

s >>= (-nBits)
nBits += eLen
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -=
8) {}

m = e & ((1 << (-nBits)) - 1)

e >>= (-nBits)
nBits += mLen
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -=
8) {}

if (e === 0) {
e = 1 - eBias
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + [Link](2, mLen)
e = e - eBias
}
return (s ? -1 : 1) * m * [Link](2, e - mLen)
}

[Link] = function (buffer, value, offset, isLE, mLen, nBytes) {

var e, m, c
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var rt = (mLen === 23 ? [Link](2, -24) - [Link](2, -77) : 0)
var i = isLE ? 0 : (nBytes - 1)
var d = isLE ? 1 : -1
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

value = [Link](value)

if (isNaN(value) || value === Infinity) {

m = isNaN(value) ? 1 : 0
e = eMax
} else {
e = [Link]([Link](value) / Math.LN2)
if (value * (c = [Link](2, -e)) < 1) {
e--
c *= 2
}
if (e + eBias >= 1) {
value += rt / c
} else {
value += rt * [Link](2, 1 - eBias)
}
if (value * c >= 2) {
e++
c /= 2
}

if (e + eBias >= eMax) {

m = 0
e = eMax
} else if (e + eBias >= 1) {
m = ((value * c) - 1) * [Link](2, mLen)
e = e + eBias
} else {
m = value * [Link](2, eBias - 1) * [Link](2, mLen)
e = 0
}
}

for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen

-= 8) {}

e = (e << mLen) | m
eLen += mLen
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen
-= 8) {}

buffer[offset + i - d] |= s * 128
}

/***/ }),

/***/ "./node_modules/int64-buffer/[Link]":
/*!***************************************************!*\
!*** ./node_modules/int64-buffer/[Link] ***!
\***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {// [Link]

/jshint -W018 / // Confusing use of '!'.

/*jshint -W030 */ // Expected an assignment or function call and
instead saw an expression.
/*jshint -W093 */ // Did you mean to return a conditional instead of an
assignment?

var Uint64BE, Int64BE, Uint64LE, Int64LE;

!function(exports) {
// constants

var UNDEFINED = "undefined";

var BUFFER = (UNDEFINED !== typeof Buffer) && Buffer;
var UINT8ARRAY = (UNDEFINED !== typeof Uint8Array) && Uint8Array;
var ARRAYBUFFER = (UNDEFINED !== typeof ArrayBuffer) &&
ArrayBuffer;
var ZERO = [0, 0, 0, 0, 0, 0, 0, 0];
var isArray = [Link] || _isArray;
var BIT32 = 4294967296;
var BIT24 = 16777216;

// storage class

var storage; // Array;

// generate classes

Uint64BE = factory("Uint64BE", true, true);

Int64BE = factory("Int64BE", true, false);
Uint64LE = factory("Uint64LE", false, true);
Int64LE = factory("Int64LE", false, false);

// class factory

function factory(name, bigendian, unsigned) {

var posH = bigendian ? 0 : 4;
var posL = bigendian ? 4 : 0;
var pos0 = bigendian ? 0 : 3;
var pos1 = bigendian ? 1 : 2;
var pos2 = bigendian ? 2 : 1;
var pos3 = bigendian ? 3 : 0;
var fromPositive = bigendian ? fromPositiveBE : fromPositiveLE;
var fromNegative = bigendian ? fromNegativeBE : fromNegativeLE;
var proto = [Link];
var isName = "is" + name;
var _isInt64 = "_" + isName;

// properties
[Link] = void 0;
[Link] = 0;
proto[_isInt64] = true;

// methods
[Link] = toNumber;
[Link] = toString;
[Link] = toNumber;
[Link] = toArray;

// add .toBuffer() method only when Buffer available

if (BUFFER) [Link] = toBuffer;

// add .toArrayBuffer() method only when Uint8Array available

if (UINT8ARRAY) [Link] = toArrayBuffer;

// isUint64BE, isInt64BE
Int64[isName] = isInt64;

// CommonJS
exports[name] = Int64;

return Int64;

// constructor
function Int64(buffer, offset, value, raddix) {
if (!(this instanceof Int64)) return new Int64(buffer,
offset, value, raddix);
return init(this, buffer, offset, value, raddix);
}

// isUint64BE, isInt64BE
function isInt64(b) {
return !!(b && b[_isInt64]);
}

// initializer
function init(that, buffer, offset, value, raddix) {
if (UINT8ARRAY && ARRAYBUFFER) {
if (buffer instanceof ARRAYBUFFER) buffer = new
UINT8ARRAY(buffer);
if (value instanceof ARRAYBUFFER) value = new
UINT8ARRAY(value);
}

// Int64BE() style
if (!buffer && !offset && !value && !storage) {
// shortcut to initialize with zero
[Link] = newArray(ZERO, 0);
return;
}

// Int64BE(value, raddix) style

if (!isValidBuffer(buffer, offset)) {
var _storage = storage || Array;
raddix = offset;
value = buffer;
offset = 0;
buffer = new _storage(8);
}

[Link] = buffer;
[Link] = offset |= 0;

// Int64BE(buffer, offset) style

if (UNDEFINED === typeof value) return;

// Int64BE(buffer, offset, value, raddix) style

if ("string" === typeof value) {
fromString(buffer, offset, value, raddix || 10);
} else if (isValidBuffer(value, raddix)) {
fromArray(buffer, offset, value, raddix);
} else if ("number" === typeof raddix) {
writeInt32(buffer, offset + posH, value); // high
writeInt32(buffer, offset + posL, raddix); // low
} else if (value > 0) {
fromPositive(buffer, offset, value); // positive
} else if (value < 0) {
fromNegative(buffer, offset, value); // negative
} else {
fromArray(buffer, offset, ZERO, 0); // zero, NaN and
others
}
}
function fromString(buffer, offset, str, raddix) {
var pos = 0;
var len = [Link];
var high = 0;
var low = 0;
if (str[0] === "-") pos++;
var sign = pos;
while (pos < len) {
var chr = parseInt(str[pos++], raddix);
if (!(chr >= 0)) break; // NaN
low = low * raddix + chr;
high = high * raddix + [Link](low / BIT32);
low %= BIT32;
}
if (sign) {
high = ~high;
if (low) {
low = BIT32 - low;
} else {
high++;
}
}
writeInt32(buffer, offset + posH, high);
writeInt32(buffer, offset + posL, low);
}

function toNumber() {
var buffer = [Link];
var offset = [Link];
var high = readInt32(buffer, offset + posH);
var low = readInt32(buffer, offset + posL);
if (!unsigned) high |= 0; // a trick to get signed
return high ? (high * BIT32 + low) : low;
}

function readInt32(buffer, offset) {

return (buffer[offset + pos0] * BIT24) +
(buffer[offset + pos1] << 16) +
(buffer[offset + pos2] << 8) +
buffer[offset + pos3];
}
}

function toArray(raw) {
var buffer = [Link];
var offset = [Link];
storage = null; // Array
if (raw !== false && offset === 0 && [Link] === 8 &&
isArray(buffer)) return buffer;
return newArray(buffer, offset);
}

function toBuffer(raw) {
var buffer = [Link];
var offset = [Link];
storage = BUFFER;
if (raw !== false && offset === 0 && [Link] === 8 &&
[Link](buffer)) return buffer;
var dest = new BUFFER(8);
fromArray(dest, 0, buffer, offset);
return dest;
}

function toArrayBuffer(raw) {
var buffer = [Link];
var offset = [Link];
var arrbuf = [Link];
storage = UINT8ARRAY;
if (raw !== false && offset === 0 && (arrbuf instanceof
ARRAYBUFFER) && [Link] === 8) return arrbuf;
var dest = new UINT8ARRAY(8);
fromArray(dest, 0, buffer, offset);
return [Link];
}

function isValidBuffer(buffer, offset) {

var len = buffer && [Link];
offset |= 0;
return len && (offset + 8 <= len) && ("string" !== typeof
buffer[offset]);
}

function fromArray(destbuf, destoff, srcbuf, srcoff) {

destoff |= 0;
srcoff |= 0;
for (var i = 0; i < 8; i++) {
destbuf[destoff++] = srcbuf[srcoff++] & 255;
}
}

function newArray(buffer, offset) {

return [Link](buffer, offset, offset + 8);
}

function fromPositiveBE(buffer, offset, value) {

var pos = offset + 8;
while (pos > offset) {
buffer[--pos] = value & 255;
value /= 256;
}
}

function fromNegativeBE(buffer, offset, value) {

var pos = offset + 8;
value++;
while (pos > offset) {
buffer[--pos] = ((-value) & 255) ^ 255;
value /= 256;
}
}

function fromPositiveLE(buffer, offset, value) {

var end = offset + 8;
while (offset < end) {
buffer[offset++] = value & 255;
value /= 256;
}
}

function fromNegativeLE(buffer, offset, value) {

var end = offset + 8;
value++;
while (offset < end) {
buffer[offset++] = ((-value) & 255) ^ 255;
value /= 256;
}
}

// [Link]
function _isArray(val) {
return !!val && "[object Array]" ==
[Link](val);
}

}( true && typeof [Link] !== 'string' ? exports : (this ||

{}));

/* WEBPACK VAR INJECTION /}.call(this, __webpack_require__(/!

./../buffer/[Link] */ "./node_modules/buffer/[Link]").Buffer))

/***/ }),
/***/ "./node_modules/is-buffer/[Link]":
/*!*****************************************!*\
!*** ./node_modules/is-buffer/[Link] ***!
\*****************************************/
/*! no static exports found */
/***/ (function(module, exports) {

/*!
* Determine if an object is a Buffer
*
* @author Feross Aboukhadijeh <[Link]
* @license MIT
*/

// The _isBuffer check is for Safari 5-7 support, because it's missing
// [Link]. Remove this eventually
[Link] = function (obj) {
return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!
obj._isBuffer)
}

function isBuffer (obj) {

return !![Link] && typeof [Link] ===
'function' && [Link](obj)
}

// For Node v0.10 support. Remove this eventually.

function isSlowBuffer (obj) {
return typeof [Link] === 'function' && typeof [Link] ===
'function' && isBuffer([Link](0, 0))
}

/***/ }),

/***/ "./node_modules/md5/[Link]":
/*!*********************************!*\
!*** ./node_modules/md5/[Link] ***!
\*********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

(function(){
var crypt = __webpack_require__(/*! crypt */
"./node_modules/crypt/[Link]"),
utf8 = __webpack_require__(/*! charenc */
"./node_modules/charenc/[Link]").utf8,
isBuffer = __webpack_require__(/*! is-buffer */ "./node_modules/is-
buffer/[Link]"),
bin = __webpack_require__(/*! charenc */
"./node_modules/charenc/[Link]").bin,

// The core
md5 = function (message, options) {
// Convert to byte array
if ([Link] == String)
if (options && [Link] === 'binary')
message = [Link](message);
else
message = [Link](message);
else if (isBuffer(message))
message = [Link](message, 0);
else if (![Link](message))
message = [Link]();
// else, assume byte array already

var m = [Link](message),
l = [Link] * 8,
a = 1732584193,
b = -271733879,
c = -1732584194,
d = 271733878;

// Swap endian
for (var i = 0; i < [Link]; i++) {
m[i] = ((m[i] << 8) | (m[i] >>> 24)) & 0x00FF00FF |
((m[i] << 24) | (m[i] >>> 8)) & 0xFF00FF00;
}

// Padding
m[l >>> 5] |= 0x80 << (l % 32);
m[(((l + 64) >>> 9) << 4) + 14] = l;

// Method shortcuts
var FF = md5._ff,
GG = md5._gg,
HH = md5._hh,
II = md5._ii;

for (var i = 0; i < [Link]; i += 16) {

var aa = a,
bb = b,
cc = c,
dd = d;

a = FF(a, b, c, d, m[i+ 0], 7, -680876936);

d = FF(d, a, b, c, m[i+ 1], 12, -389564586);
c = FF(c, d, a, b, m[i+ 2], 17, 606105819);
b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);
a = FF(a, b, c, d, m[i+ 4], 7, -176418897);
d = FF(d, a, b, c, m[i+ 5], 12, 1200080426);
c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);
b = FF(b, c, d, a, m[i+ 7], 22, -45705983);
a = FF(a, b, c, d, m[i+ 8], 7, 1770035416);
d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);
c = FF(c, d, a, b, m[i+10], 17, -42063);
b = FF(b, c, d, a, m[i+11], 22, -1990404162);
a = FF(a, b, c, d, m[i+12], 7, 1804603682);
d = FF(d, a, b, c, m[i+13], 12, -40341101);
c = FF(c, d, a, b, m[i+14], 17, -1502002290);
b = FF(b, c, d, a, m[i+15], 22, 1236535329);

a = GG(a, b, c, d, m[i+ 1], 5, -165796510);

d = GG(d, a, b, c, m[i+ 6], 9, -1069501632);
c = GG(c, d, a, b, m[i+11], 14, 643717713);
b = GG(b, c, d, a, m[i+ 0], 20, -373897302);
a = GG(a, b, c, d, m[i+ 5], 5, -701558691);
d = GG(d, a, b, c, m[i+10], 9, 38016083);
c = GG(c, d, a, b, m[i+15], 14, -660478335);
b = GG(b, c, d, a, m[i+ 4], 20, -405537848);
a = GG(a, b, c, d, m[i+ 9], 5, 568446438);
d = GG(d, a, b, c, m[i+14], 9, -1019803690);
c = GG(c, d, a, b, m[i+ 3], 14, -187363961);
b = GG(b, c, d, a, m[i+ 8], 20, 1163531501);
a = GG(a, b, c, d, m[i+13], 5, -1444681467);
d = GG(d, a, b, c, m[i+ 2], 9, -51403784);
c = GG(c, d, a, b, m[i+ 7], 14, 1735328473);
b = GG(b, c, d, a, m[i+12], 20, -1926607734);

a = HH(a, b, c, d, m[i+ 5], 4, -378558);

d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);
c = HH(c, d, a, b, m[i+11], 16, 1839030562);
b = HH(b, c, d, a, m[i+14], 23, -35309556);
a = HH(a, b, c, d, m[i+ 1], 4, -1530992060);
d = HH(d, a, b, c, m[i+ 4], 11, 1272893353);
c = HH(c, d, a, b, m[i+ 7], 16, -155497632);
b = HH(b, c, d, a, m[i+10], 23, -1094730640);
a = HH(a, b, c, d, m[i+13], 4, 681279174);
d = HH(d, a, b, c, m[i+ 0], 11, -358537222);
c = HH(c, d, a, b, m[i+ 3], 16, -722521979);
b = HH(b, c, d, a, m[i+ 6], 23, 76029189);
a = HH(a, b, c, d, m[i+ 9], 4, -640364487);
d = HH(d, a, b, c, m[i+12], 11, -421815835);
c = HH(c, d, a, b, m[i+15], 16, 530742520);
b = HH(b, c, d, a, m[i+ 2], 23, -995338651);

a = II(a, b, c, d, m[i+ 0], 6, -198630844);

d = II(d, a, b, c, m[i+ 7], 10, 1126891415);
c = II(c, d, a, b, m[i+14], 15, -1416354905);
b = II(b, c, d, a, m[i+ 5], 21, -57434055);
a = II(a, b, c, d, m[i+12], 6, 1700485571);
d = II(d, a, b, c, m[i+ 3], 10, -1894986606);
c = II(c, d, a, b, m[i+10], 15, -1051523);
b = II(b, c, d, a, m[i+ 1], 21, -2054922799);
a = II(a, b, c, d, m[i+ 8], 6, 1873313359);
d = II(d, a, b, c, m[i+15], 10, -30611744);
c = II(c, d, a, b, m[i+ 6], 15, -1560198380);
b = II(b, c, d, a, m[i+13], 21, 1309151649);
a = II(a, b, c, d, m[i+ 4], 6, -145523070);
d = II(d, a, b, c, m[i+11], 10, -1120210379);
c = II(c, d, a, b, m[i+ 2], 15, 718787259);
b = II(b, c, d, a, m[i+ 9], 21, -343485551);

a = (a + aa) >>> 0;
b = (b + bb) >>> 0;
c = (c + cc) >>> 0;
d = (d + dd) >>> 0;
}

return [Link]([a, b, c, d]);

};

// Auxiliary functions
md5._ff = function (a, b, c, d, x, s, t) {
var n = a + (b & c | ~b & d) + (x >>> 0) + t;
return ((n << s) | (n >>> (32 - s))) + b;
};
md5._gg = function (a, b, c, d, x, s, t) {
var n = a + (b & d | c & ~d) + (x >>> 0) + t;
return ((n << s) | (n >>> (32 - s))) + b;
};
md5._hh = function (a, b, c, d, x, s, t) {
var n = a + (b ^ c ^ d) + (x >>> 0) + t;
return ((n << s) | (n >>> (32 - s))) + b;
};
md5._ii = function (a, b, c, d, x, s, t) {
var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
return ((n << s) | (n >>> (32 - s))) + b;
};

// Package private blocksize

md5._blocksize = 16;
md5._digestsize = 16;

[Link] = function (message, options) {

if (message === undefined || message === null)
throw new Error('Illegal argument ' + message);

var digestbytes = [Link](md5(message, options));

return options && [Link] ? digestbytes :
options && [Link] ? [Link](digestbytes) :
[Link](digestbytes);
};

})();

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!**************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

[Link] = __webpack_require__(/! ./encode /

"./node_modules/msgpack-lite/lib/[Link]").encode;
[Link] = __webpack_require__(/*! ./decode */
"./node_modules/msgpack-lite/lib/[Link]").decode;

[Link] = __webpack_require__(/! ./encoder /

"./node_modules/msgpack-lite/lib/[Link]").Encoder;
[Link] = __webpack_require__(/*! ./decoder */
"./node_modules/msgpack-lite/lib/[Link]").Decoder;

[Link] = __webpack_require__(/! ./ext /

"./node_modules/msgpack-lite/lib/[Link]").createCodec;
[Link] = __webpack_require__(/*! ./codec */ "./node_modules/msgpack-
lite/lib/[Link]").codec;

/***/ }),
/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!********************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION /(function(Buffer) {/ globals Buffer */

[Link] =
c(("undefined" !== typeof Buffer) && Buffer) ||
c([Link]) ||
c(("undefined" !== typeof window) && [Link]) ||
[Link];

function c(B) {
return B && [Link] && B;
}
/* WEBPACK VAR INJECTION */}.call(this,
__webpack_require__(/*! ./../../buffer/[Link] */
"./node_modules/buffer/[Link]").Buffer))

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!******************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\******************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// [Link]

var MAXBUFLEN = 8192;

[Link] = copy;
[Link] = toString;
[Link] = write;

/**
* [Link]()
*
* @param string {String}
* @param [offset] {Number}
* @returns {Number}
*/

function write(string, offset) {

var buffer = this;
var index = offset || (offset |= 0);
var length = [Link];
var chr = 0;
var i = 0;
while (i < length) {
chr = [Link](i++);

if (chr < 128) {

buffer[index++] = chr;
} else if (chr < 0x800) {
// 2 bytes
buffer[index++] = 0xC0 | (chr >>> 6);
buffer[index++] = 0x80 | (chr & 0x3F);
} else if (chr < 0xD800 || chr > 0xDFFF) {
// 3 bytes
buffer[index++] = 0xE0 | (chr >>> 12);
buffer[index++] = 0x80 | ((chr >>> 6) & 0x3F);
buffer[index++] = 0x80 | (chr & 0x3F);
} else {
// 4 bytes - surrogate pair
chr = (((chr - 0xD800) << 10) | ([Link](i++) -
0xDC00)) + 0x10000;
buffer[index++] = 0xF0 | (chr >>> 18);
buffer[index++] = 0x80 | ((chr >>> 12) & 0x3F);
buffer[index++] = 0x80 | ((chr >>> 6) & 0x3F);
buffer[index++] = 0x80 | (chr & 0x3F);
}
}
return index - offset;
}

/**
* [Link]()
*
* @param [encoding] {String} ignored
* @param [start] {Number}
* @param [end] {Number}
* @returns {String}
*/

function toString(encoding, start, end) {

var buffer = this;
var index = start|0;
if (!end) end = [Link];
var string = '';
var chr = 0;

while (index < end) {

chr = buffer[index++];
if (chr < 128) {
string += [Link](chr);
continue;
}

if ((chr & 0xE0) === 0xC0) {

// 2 bytes
chr = (chr & 0x1F) << 6 |
(buffer[index++] & 0x3F);

} else if ((chr & 0xF0) === 0xE0) {

// 3 bytes
chr = (chr & 0x0F) << 12 |
(buffer[index++] & 0x3F) << 6 |
(buffer[index++] & 0x3F);

} else if ((chr & 0xF8) === 0xF0) {

// 4 bytes
chr = (chr & 0x07) << 18 |
(buffer[index++] & 0x3F) << 12 |
(buffer[index++] & 0x3F) << 6 |
(buffer[index++] & 0x3F);
}

if (chr >= 0x010000) {

// A surrogate pair
chr -= 0x010000;

string += [Link]((chr >>> 10) + 0xD800, (chr &

0x3FF) + 0xDC00);
} else {
string += [Link](chr);
}
}

return string;
}

/**
* [Link]()
*
* @param target {Buffer}
* @param [targetStart] {Number}
* @param [start] {Number}
* @param [end] {Number}
* @returns {number}
*/

function copy(target, targetStart, start, end) {

var i;
if (!start) start = 0;
if (!end && end !== 0) end = [Link];
if (!targetStart) targetStart = 0;
var len = end - start;

if (target === this && start < targetStart && targetStart < end) {
// descending
for (i = len - 1; i >= 0; i--) {
target[i + targetStart] = this[i + start];
}
} else {
// ascending
for (i = 0; i < len; i++) {
target[i + targetStart] = this[i + start];
}
}

return len;
}

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!**********************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");

var exports = [Link] = alloc(0);

[Link] = alloc;
[Link] = [Link];
[Link] = from;

/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/

function alloc(size) {
return new Array(size);
}

/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Array}
*/

// Array-like to Array
return [Link](value);
}

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!***********************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");
var Buffer = [Link];

var exports = [Link] = [Link] ? alloc(0) : [];

[Link] = [Link] && [Link] || alloc;

[Link] = [Link];
[Link] = from;

/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/

function alloc(size) {
return new Buffer(size);
}

/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Buffer}
*/

// Array-like to Buffer
if ([Link] && [Link] !== 1) {
return [Link](value); // node v6+
} else {
return new Buffer(value); // node v4
}
}

/***/ }),

// [Link]

/* jshint eqnull:true */

var BufferLite = __webpack_require__(/! ./buffer-lite /

"./node_modules/msgpack-lite/lib/[Link]");

[Link] = copy;
[Link] = slice;
[Link] = toString;
[Link] = gen("write");

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");
var Buffer = [Link];

var isBufferShim = [Link] && ("TYPED_ARRAY_SUPPORT" in

Buffer);
var brokenTypedArray = isBufferShim && !Buffer.TYPED_ARRAY_SUPPORT;

/**
* @param target {Buffer|Uint8Array|Array}
* @param [targetStart] {Number}
* @param [start] {Number}
* @param [end] {Number}
* @returns {Buffer|Uint8Array|Array}
*/

function copy(target, targetStart, start, end) {

/**
* @param [start] {Number}
* @param [end] {Number}
* @returns {Buffer|Uint8Array|Array}
*/

function slice(start, end) {

// for Buffer, Uint8Array (except for minor some browsers) and Array
var f = [Link] || (!brokenTypedArray && [Link]);
if (f) return [Link](this, start, end);

// Uint8Array (for minor some browsers)

function toString(encoding, start, end) {

var f = (!isBufferShim && [Link](this)) ? [Link] :
[Link];
return [Link](this, arguments);
}

/**
* @private
*/

function gen(method) {
return wrap;

function wrap() {
var f = this[method] || BufferLite[method];
return [Link](this, arguments);
}
}

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!***************************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");

var exports = [Link] = [Link] ? alloc(0) : [];

[Link] = alloc;
[Link] = [Link];
[Link] = from;

/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/

function alloc(size) {
return new Uint8Array(size);
}

/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Uint8Array}
*/

return new Uint8Array(value);

}

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!****************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

var Buffer = [Link] = __webpack_require__(/! ./buffer-global /

"./node_modules/msgpack-lite/lib/[Link]");
var hasBuffer = [Link] = Buffer && !![Link];
var hasArrayBuffer = [Link] = ("undefined" !== typeof
ArrayBuffer);

var isArray = [Link] = __webpack_require__(/! isarray /

"./node_modules/msgpack-lite/node_modules/isarray/[Link]");
[Link] = hasArrayBuffer ? isArrayBuffer : _false;
var isBuffer = [Link] = hasBuffer ? [Link] : _false;
var isView = [Link] = hasArrayBuffer ? ([Link] ||
_is("ArrayBuffer", "buffer")) : _false;

[Link] = alloc;
[Link] = concat;
[Link] = from;

var BufferArray = [Link] = __webpack_require__(/*! ./bufferish-array

*/ "./node_modules/msgpack-lite/lib/[Link]");
var BufferBuffer = [Link] = __webpack_require__(/*! ./bufferish-
buffer */ "./node_modules/msgpack-lite/lib/[Link]");
var BufferUint8Array = exports.Uint8Array = __webpack_require__(/*!
./bufferish-uint8array */ "./node_modules/msgpack-lite/lib/bufferish-
[Link]");
var BufferProto = [Link] = __webpack_require__(/*! ./bufferish-
proto */ "./node_modules/msgpack-lite/lib/[Link]");

/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Buffer|Uint8Array|Array}
*/

function from(value) {
if (typeof value === "string") {
return [Link](this, value);
} else {
return auto(this).from(value);
}
}

/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/

function alloc(size) {
return auto(this).alloc(size);
}

/**
* @param list {Array} array of (Buffer|Uint8Array|Array)s
* @param [length]
* @returns {Buffer|Uint8Array|Array}
*/

function concat(list, length) {

if (!length) {
length = 0;
[Link](list, dryrun);
}
var ref = (this !== exports) && this || list[0];
var result = [Link](ref, length);
var offset = 0;
[Link](list, append);
return result;

function dryrun(buffer) {
length += [Link];
}

function append(buffer) {
offset += [Link](buffer, result, offset);
}
}

var _isArrayBuffer = _is("ArrayBuffer");

function isArrayBuffer(value) {
return (value instanceof ArrayBuffer) || _isArrayBuffer(value);
}

/**
* @private
*/

function fromString(value) {
var expected = [Link] * 3;
var that = [Link](this, expected);
var actual = [Link](that, value);
if (expected !== actual) {
that = [Link](that, 0, actual);
}
return that;
}

function auto(that) {
return isBuffer(that) ? BufferBuffer
: isView(that) ? BufferUint8Array
: isArray(that) ? BufferArray
: hasBuffer ? BufferBuffer
: hasArrayBuffer ? BufferUint8Array
: BufferArray;
}

function _false() {
return false;
}

function _is(name, key) {

/* jshint eqnull:true */
name = "[object " + name + "]";
return function(value) {
return (value != null) && {}.[Link](key ? value[key] :
value) === name;
};
}

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!*****************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

var IS_ARRAY = __webpack_require__(/! isarray / "./node_modules/msgpack-

lite/node_modules/isarray/[Link]");

[Link] = createCodec;
[Link] = install;
[Link] = filter;

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");

function Codec(options) {
if (!(this instanceof Codec)) return new Codec(options);
[Link] = options;
[Link]();
}

[Link] = function() {
var options = [Link];

if (options && options.uint8array) {

[Link] = Bufferish.Uint8Array;
}

return this;
};

function install(props) {
for (var key in props) {
[Link][key] = add([Link][key], props[key]);
}
}

function add(a, b) {
return (a && b) ? ab : (a || b);

function ab() {
[Link](this, arguments);
return [Link](this, arguments);
}
}

function join(filters) {
filters = [Link]();

return function(value) {
return [Link](iterator, value);
};

function iterator(value, filter) {

return filter(value);
}
}

function filter(filter) {
return IS_ARRAY(filter) ? join(filter) : filter;
}

// @public
// [Link]()

function createCodec(options) {
return new Codec(options);
}
// default shared codec

[Link] = createCodec({preset: true});

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

// load both interfaces

__webpack_require__(/*! ./read-core */
"./node_modules/msgpack-lite/lib/[Link]");
__webpack_require__(/*! ./write-core */
"./node_modules/msgpack-lite/lib/[Link]");

// @public
// [Link]

[Link] = {
preset: __webpack_require__(/*! ./codec-base */
"./node_modules/msgpack-lite/lib/[Link]").preset
};

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!********************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

[Link] = DecodeBuffer;

var preset = __webpack_require__(/! ./read-core /

"./node_modules/msgpack-lite/lib/[Link]").preset;

var FlexDecoder = __webpack_require__(/! ./flex-buffer /

"./node_modules/msgpack-lite/lib/[Link]").FlexDecoder;

[Link]([Link]);

function DecodeBuffer(options) {
if (!(this instanceof DecodeBuffer)) return new DecodeBuffer(options);

if (options) {
[Link] = options;
if ([Link]) {
var codec = [Link] = [Link];
if ([Link]) [Link] = [Link];
}
}
}

[Link] = preset;

[Link] = function() {
return [Link](this);
};

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!*************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

[Link] = decode;

var DecodeBuffer = __webpack_require__(/! ./decode-buffer /

"./node_modules/msgpack-lite/lib/[Link]").DecodeBuffer;

function decode(input, options) {

var decoder = new DecodeBuffer(options);
[Link](input);
return [Link]();
}

/***/ }),

// [Link]

[Link] = Decoder;

var EventLite = __webpack_require__(/! event-lite /

"./node_modules/event-lite/[Link]");
var DecodeBuffer = __webpack_require__(/*! ./decode-buffer */
"./node_modules/msgpack-lite/lib/[Link]").DecodeBuffer;

function Decoder(options) {
if (!(this instanceof Decoder)) return new Decoder(options);
[Link](this, options);
}

[Link] = new DecodeBuffer();

[Link]([Link]);

[Link] = function(chunk) {
if ([Link]) [Link](chunk);
[Link]();
};

[Link] = function(chunk) {
[Link]("data", chunk);
};

[Link] = function(chunk) {
[Link](chunk);
[Link]("end");
};

/***/ }),

// [Link]

[Link] = EncodeBuffer;

var preset = __webpack_require__(/! ./write-core /

"./node_modules/msgpack-lite/lib/[Link]").preset;

var FlexEncoder = __webpack_require__(/! ./flex-buffer /

"./node_modules/msgpack-lite/lib/[Link]").FlexEncoder;

[Link]([Link]);

function EncodeBuffer(options) {
if (!(this instanceof EncodeBuffer)) return new EncodeBuffer(options);

if (options) {
[Link] = options;
if ([Link]) {
var codec = [Link] = [Link];
if ([Link]) [Link] = [Link];
}
}
}

[Link] = preset;

[Link] = function(input) {
[Link](this, input);
};

/***/ }),
/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!*************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

[Link] = encode;

var EncodeBuffer = __webpack_require__(/! ./encode-buffer /

"./node_modules/msgpack-lite/lib/[Link]").EncodeBuffer;

function encode(input, options) {

var encoder = new EncodeBuffer(options);
[Link](input);
return [Link]();
}

/***/ }),

// [Link]

[Link] = Encoder;

var EventLite = __webpack_require__(/! event-lite /

"./node_modules/event-lite/[Link]");
var EncodeBuffer = __webpack_require__(/*! ./encode-buffer */
"./node_modules/msgpack-lite/lib/[Link]").EncodeBuffer;

function Encoder(options) {
if (!(this instanceof Encoder)) return new Encoder(options);
[Link](this, options);
}

[Link] = new EncodeBuffer();

[Link]([Link]);

[Link] = function(chunk) {
[Link](chunk);
[Link]("data", [Link]());
};

[Link] = function(chunk) {
if ([Link]) [Link](chunk);
[Link]();
[Link]("end");
};
/***/ }),

// [Link]

[Link] = ExtBuffer;

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");

function ExtBuffer(buffer, type) {

if (!(this instanceof ExtBuffer)) return new ExtBuffer(buffer, type);
[Link] = [Link](buffer);
[Link] = type;
}

/***/ }),

// [Link]

[Link] = setExtPackers;

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");
var Buffer = [Link];
var packTypedArray = [Link];
var _encode;

var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1,

fileName: 1, lineNumber: 1};

function setExtPackers(codec) {
[Link](0x0E, Error, [packError, encode]);
[Link](0x01, EvalError, [packError, encode]);
[Link](0x02, RangeError, [packError, encode]);
[Link](0x03, ReferenceError, [packError, encode]);
[Link](0x04, SyntaxError, [packError, encode]);
[Link](0x05, TypeError, [packError, encode]);
[Link](0x06, URIError, [packError, encode]);

[Link](0x0A, RegExp, [packRegExp, encode]);

[Link](0x0B, Boolean, [packValueOf, encode]);
[Link](0x0C, String, [packValueOf, encode]);
[Link](0x0D, Date, [Number, encode]);
[Link](0x0F, Number, [packValueOf, encode]);

if ("undefined" !== typeof Uint8Array) {

[Link](0x11, Int8Array, packTypedArray);
[Link](0x12, Uint8Array, packTypedArray);
[Link](0x13, Int16Array, packTypedArray);
[Link](0x14, Uint16Array, packTypedArray);
[Link](0x15, Int32Array, packTypedArray);
[Link](0x16, Uint32Array, packTypedArray);
[Link](0x17, Float32Array, packTypedArray);

// PhantomJS/1.9.7 doesn't have Float64Array

if ("undefined" !== typeof Float64Array) {
[Link](0x18, Float64Array, packTypedArray);
}

// IE10 doesn't have Uint8ClampedArray

if ("undefined" !== typeof Uint8ClampedArray) {
[Link](0x19, Uint8ClampedArray, packTypedArray);
}

[Link](0x1A, ArrayBuffer, packTypedArray);

[Link](0x1D, DataView, packTypedArray);
}

if ([Link]) {
[Link](0x1B, Buffer, [Link]);
}
}

function encode(input) {
if (!_encode) _encode = __webpack_require__(/*! ./encode */
"./node_modules/msgpack-lite/lib/[Link]").encode; // lazy load
return _encode(input);
}

function packValueOf(value) {
return (value).valueOf();
}

function packRegExp(value) {
value = [Link](value).split("/");
[Link]();
var out = [[Link]()];
[Link]([Link]("/"));
return out;
}

function packError(value) {
var out = {};
for (var key in ERROR_COLUMNS) {
out[key] = value[key];
}
return out;
}

/***/ }),
/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!*******************************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

[Link] = setExtUnpackers;

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");
var Buffer = [Link];
var _decode;

var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1,

fileName: 1, lineNumber: 1};

function setExtUnpackers(codec) {
[Link](0x0E, [decode, unpackError(Error)]);
[Link](0x01, [decode, unpackError(EvalError)]);
[Link](0x02, [decode, unpackError(RangeError)]);
[Link](0x03, [decode, unpackError(ReferenceError)]);
[Link](0x04, [decode, unpackError(SyntaxError)]);
[Link](0x05, [decode, unpackError(TypeError)]);
[Link](0x06, [decode, unpackError(URIError)]);

[Link](0x0A, [decode, unpackRegExp]);

[Link](0x0B, [decode, unpackClass(Boolean)]);
[Link](0x0C, [decode, unpackClass(String)]);
[Link](0x0D, [decode, unpackClass(Date)]);
[Link](0x0F, [decode, unpackClass(Number)]);

if ("undefined" !== typeof Uint8Array) {

[Link](0x11, unpackClass(Int8Array));
[Link](0x12, unpackClass(Uint8Array));
[Link](0x13, [unpackArrayBuffer,
unpackClass(Int16Array)]);
[Link](0x14, [unpackArrayBuffer,
unpackClass(Uint16Array)]);
[Link](0x15, [unpackArrayBuffer,
unpackClass(Int32Array)]);
[Link](0x16, [unpackArrayBuffer,
unpackClass(Uint32Array)]);
[Link](0x17, [unpackArrayBuffer,
unpackClass(Float32Array)]);

// PhantomJS/1.9.7 doesn't have Float64Array

if ("undefined" !== typeof Float64Array) {
[Link](0x18, [unpackArrayBuffer,
unpackClass(Float64Array)]);
}

// IE10 doesn't have Uint8ClampedArray

if ("undefined" !== typeof Uint8ClampedArray) {
[Link](0x19, unpackClass(Uint8ClampedArray));
}
[Link](0x1A, unpackArrayBuffer);
[Link](0x1D, [unpackArrayBuffer,
unpackClass(DataView)]);
}

if ([Link]) {
[Link](0x1B, unpackClass(Buffer));
}
}

function decode(input) {
if (!_decode) _decode = __webpack_require__(/*! ./decode */
"./node_modules/msgpack-lite/lib/[Link]").decode; // lazy load
return _decode(input);
}

function unpackRegExp(value) {
return [Link](null, value);
}

function unpackError(Class) {
return function(value) {
var out = new Class();
for (var key in ERROR_COLUMNS) {
out[key] = value[key];
}
return out;
};
}

function unpackClass(Class) {
return function(value) {
return new Class(value);
};
}

function unpackArrayBuffer(value) {
return (new Uint8Array(value)).buffer;
}

/***/ }),

/***/ "./node_modules/msgpack-lite/lib/[Link]":
/*!**********************************************!*\
!*** ./node_modules/msgpack-lite/lib/[Link] ***!
\**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// [Link]

// load both interfaces

__webpack_require__(/*! ./read-core */
"./node_modules/msgpack-lite/lib/[Link]");
__webpack_require__(/*! ./write-core */
"./node_modules/msgpack-lite/lib/[Link]");
[Link] = __webpack_require__(/*! ./codec-base */
"./node_modules/msgpack-lite/lib/[Link]").createCodec;

/***/ }),

// [Link]

[Link] = FlexDecoder;
[Link] = FlexEncoder;

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");

var MIN_BUFFER_SIZE = 2048;

var MAX_BUFFER_SIZE = 65536;
var BUFFER_SHORTAGE = "BUFFER_SHORTAGE";

function FlexDecoder() {
if (!(this instanceof FlexDecoder)) return new FlexDecoder();
}

function FlexEncoder() {
if (!(this instanceof FlexEncoder)) return new FlexEncoder();
}

[Link] = mixinFactory(getDecoderMethods());
[Link]([Link]);

[Link] = mixinFactory(getEncoderMethods());
[Link]([Link]);

function getDecoderMethods() {
return {
bufferish: Bufferish,
write: write,
fetch: fetch,
flush: flush,
push: push,
pull: pull,
read: read,
reserve: reserve,
offset: 0
};

function reserve(length) {
var start = [Link];
var end = start + length;
if (end > [Link]) throw new Error(BUFFER_SHORTAGE);
[Link] = end;
return start;
}
}

function getEncoderMethods() {
return {
bufferish: Bufferish,
write: write,
fetch: fetch,
flush: flush,
push: push,
pull: pull,
read: read,
reserve: reserve,
send: send,
maxBufferSize: MAX_BUFFER_SIZE,
minBufferSize: MIN_BUFFER_SIZE,
offset: 0,
start: 0
};

function fetch() {
var start = [Link];
if (start < [Link]) {
var end = [Link] = [Link];
return [Link]([Link], start, end);
}
}

function flush() {
while ([Link] < [Link]) {
var value = [Link]();
if (value) [Link](value);
}
}

function pull() {
var buffers = [Link] || ([Link] = []);
var chunk = [Link] > 1 ? [Link](buffers) :
buffers[0];
[Link] = 0; // buffer exhausted
return chunk;
}

function reserve(length) {
var req = length | 0;

if ([Link]) {
var size = [Link];
var start = [Link] | 0;
var end = start + req;

// is it long enough?
if (end < size) {
[Link] = end;
return start;
}

// flush current buffer

[Link]();

// resize it to 2x current length

length = [Link](length, [Link](size * 2,
[Link]));
}

// minimum buffer size

length = [Link](length, [Link]);

// allocate new buffer

[Link] = [Link](length);
[Link] = 0;
[Link] = req;
return 0;
}

function send(buffer) {
var length = [Link];
if (length > [Link]) {
[Link]();
[Link](buffer);
} else {
var offset = [Link](length);
[Link](buffer, [Link], offset);
}
}
}

// common methods

function write() {
throw new Error("method not implemented: write()");
}

function fetch() {
throw new Error("method not implemented: fetch()");
}

function read() {
var length = [Link] && [Link];

// fetch the first result

if (!length) return [Link]();

// flush current buffer

[Link]();

// read from the results

return [Link]();
}

function push(chunk) {
var buffers = [Link] || ([Link] = []);
[Link](chunk);
}

function pull() {
var buffers = [Link] || ([Link] = []);
return [Link]();
}

function mixinFactory(source) {
return mixin;

function mixin(target) {
for (var key in source) {
target[key] = source[key];
}
return target;
}
}

/***/ }),

// [Link]

var ExtBuffer = __webpack_require__(/! ./ext-buffer /

"./node_modules/msgpack-lite/lib/[Link]").ExtBuffer;
var ExtUnpacker = __webpack_require__(/*! ./ext-unpacker */
"./node_modules/msgpack-lite/lib/[Link]");
var readUint8 = __webpack_require__(/*! ./read-format */
"./node_modules/msgpack-lite/lib/[Link]").readUint8;
var ReadToken = __webpack_require__(/*! ./read-token */
"./node_modules/msgpack-lite/lib/[Link]");
var CodecBase = __webpack_require__(/*! ./codec-base */
"./node_modules/msgpack-lite/lib/[Link]");
[Link]({
addExtUnpacker: addExtUnpacker,
getExtUnpacker: getExtUnpacker,
init: init
});

[Link] = [Link]([Link]);

function getDecoder(options) {
var readToken = [Link](options);
return decode;

function decode(decoder) {
var type = readUint8(decoder);
var func = readToken[type];
if (!func) throw new Error("Invalid type: " + (type ? ("0x" +
[Link](16)) : type));
return func(decoder);
}
}

function init() {
var options = [Link];
[Link] = getDecoder(options);

if (options && [Link]) {

[Link](this);
}

return this;
}

function addExtUnpacker(etype, unpacker) {

var unpackers = [Link] || ([Link] = []);
unpackers[etype] = [Link](unpacker);
}

function getExtUnpacker(type) {
var unpackers = [Link] || ([Link] = []);
return unpackers[type] || extUnpacker;

function extUnpacker(buffer) {
return new ExtBuffer(buffer, type);
}
}

/***/ }),

// [Link]

var ieee754 = __webpack_require__(/! ieee754 /

"./node_modules/ieee754/[Link]");
var Int64Buffer = __webpack_require__(/*! int64-buffer */
"./node_modules/int64-buffer/[Link]");
var Uint64BE = Int64Buffer.Uint64BE;
var Int64BE = Int64Buffer.Int64BE;

[Link] = getReadFormat;
exports.readUint8 = uint8;

var Bufferish = __webpack_require__(/! ./bufferish /

"./node_modules/msgpack-lite/lib/[Link]");
var BufferProto = __webpack_require__(/*! ./bufferish-proto */
"./node_modules/msgpack-lite/lib/[Link]");

var HAS_MAP = ("undefined" !== typeof Map);

var NO_ASSERT = true;

function getReadFormat(options) {
var binarraybuffer = [Link] && options &&
[Link];
var int64 = options && options.int64;
var usemap = HAS_MAP && options && [Link];

var readFormat = {
map: (usemap ? map_to_map : map_to_obj),
array: array,
str: str,
bin: (binarraybuffer ? bin_arraybuffer : bin_buffer),
ext: ext,
uint8: uint8,
uint16: uint16,
uint32: uint32,
uint64: read(8, int64 ? readUInt64BE_int64 : readUInt64BE),
int8: int8,
int16: int16,
int32: int32,
int64: read(8, int64 ? readInt64BE_int64 : readInt64BE),
float32: read(4, readFloatBE),
float64: read(8, readDoubleBE)
};

return readFormat;
}

function map_to_obj(decoder, len) {

var value = {};
var i;
var k = new Array(len);
var v = new Array(len);

function map_to_map(decoder, len) {

var value = new Map();
var i;
var k = new Array(len);
var v = new Array(len);

function array(decoder, len) {

var value = new Array(len);
var decode = [Link];
for (var i = 0; i < len; i++) {
value[i] = decode(decoder);
}
return value;
}

function str(decoder, len) {

var start = [Link](len);
var end = start + len;
return [Link]([Link], "utf-8", start, end);
}

function bin_buffer(decoder, len) {

var start = [Link](len);
var end = start + len;
var buf = [Link]([Link], start, end);
return [Link](buf);
}

function bin_arraybuffer(decoder, len) {

var start = [Link](len);
var end = start + len;
var buf = [Link]([Link], start, end);
return [Link](buf).buffer;
}

function ext(decoder, len) {

var start = [Link](len+1);
var type = [Link][start++];
var end = start + len;
var unpack = [Link](type);
if (!unpack) throw new Error("Invalid ext type: " + (type ? ("0x" +
[Link](16)) : type));
var buf = [Link]([Link], start, end);
return unpack(buf);
}
function uint8(decoder) {
var start = [Link](1);
return [Link][start];
}

function int8(decoder) {
var start = [Link](1);
var value = [Link][start];
return (value & 0x80) ? value - 0x100 : value;
}

function uint16(decoder) {
var start = [Link](2);
var buffer = [Link];
return (buffer[start++] << 8) | buffer[start];
}

function int16(decoder) {
var start = [Link](2);
var buffer = [Link];
var value = (buffer[start++] << 8) | buffer[start];
return (value & 0x8000) ? value - 0x10000 : value;
}

function uint32(decoder) {
var start = [Link](4);
var buffer = [Link];
return (buffer[start++] * 16777216) + (buffer[start++] << 16) +
(buffer[start++] << 8) + buffer[start];
}

function int32(decoder) {
var start = [Link](4);
var buffer = [Link];
return (buffer[start++] << 24) | (buffer[start++] << 16) |
(buffer[start++] << 8) | buffer[start];
}

function read(len, method) {

return function(decoder) {
var start = [Link](len);
return [Link]([Link], start, NO_ASSERT);
};
}

function readUInt64BE(start) {
return new Uint64BE(this, start).toNumber();
}

function readInt64BE(start) {
return new Int64BE(this, start).toNumber();
}

function readUInt64BE_int64(start) {
return new Uint64BE(this, start);
}

function readInt64BE_int64(start) {
return new Int64BE(this, start);
}

function readFloatBE(start) {
return [Link](this, start, false, 23, 4);
}

function readDoubleBE(start) {
return [Link](this, start, false, 52, 8);
}

/***/ }),

// [Link]

var ReadFormat = __webpack_require__(/! ./read-format /

"./node_modules/msgpack-lite/lib/[Link]");

[Link] = getReadToken;

function getReadToken(options) {
var format = [Link](options);

if (options && [Link]) {

return init_useraw(format);
} else {
return init_token(format);
}
}

function init_token(format) {
var i;
var token = new Array(256);

// positive fixint -- 0x00 - 0x7f

for (i = 0x00; i <= 0x7f; i++) {
token[i] = constant(i);
}

// fixmap -- 0x80 - 0x8f

for (i = 0x80; i <= 0x8f; i++) {
token[i] = fix(i - 0x80, [Link]);
}

// fixarray -- 0x90 - 0x9f

for (i = 0x90; i <= 0x9f; i++) {
token[i] = fix(i - 0x90, [Link]);
}

// fixstr -- 0xa0 - 0xbf

for (i = 0xa0; i <= 0xbf; i++) {
token[i] = fix(i - 0xa0, [Link]);
}
// nil -- 0xc0
token[0xc0] = constant(null);

// (never used) -- 0xc1

token[0xc1] = null;

// false -- 0xc2
// true -- 0xc3
token[0xc2] = constant(false);
token[0xc3] = constant(true);

// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
token[0xc4] = flex(format.uint8, [Link]);
token[0xc5] = flex(format.uint16, [Link]);
token[0xc6] = flex(format.uint32, [Link]);

// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
token[0xc7] = flex(format.uint8, [Link]);
token[0xc8] = flex(format.uint16, [Link]);
token[0xc9] = flex(format.uint32, [Link]);

// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = format.float32;
token[0xcb] = format.float64;

// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
token[0xcc] = format.uint8;
token[0xcd] = format.uint16;
token[0xce] = format.uint32;
token[0xcf] = format.uint64;

// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
token[0xd0] = format.int8;
token[0xd1] = format.int16;
token[0xd2] = format.int32;
token[0xd3] = format.int64;

// fixext 1 -- 0xd4
// fixext 2 -- 0xd5
// fixext 4 -- 0xd6
// fixext 8 -- 0xd7
// fixext 16 -- 0xd8
token[0xd4] = fix(1, [Link]);
token[0xd5] = fix(2, [Link]);
token[0xd6] = fix(4, [Link]);
token[0xd7] = fix(8, [Link]);
token[0xd8] = fix(16, [Link]);
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
token[0xd9] = flex(format.uint8, [Link]);
token[0xda] = flex(format.uint16, [Link]);
token[0xdb] = flex(format.uint32, [Link]);

// array 16 -- 0xdc
// array 32 -- 0xdd
token[0xdc] = flex(format.uint16, [Link]);
token[0xdd] = flex(format.uint32, [Link]);

// map 16 -- 0xde
// map 32 -- 0xdf
token[0xde] = flex(format.uint16, [Link]);
token[0xdf] = flex(format.uint32, [Link]);

// negative fixint -- 0xe0 - 0xff

for (i = 0xe0; i <= 0xff; i++) {
token[i] = constant(i - 0x100);
}

return token;
}

function init_useraw(format) {
var i;
var token = init_token(format).slice();

// raw 8 -- 0xd9
// raw 16 -- 0xda
// raw 32 -- 0xdb
token[0xd9] = token[0xc4];
token[0xda] = token[0xc5];
token[0xdb] = token[0xc6];

// fixraw -- 0xa0 - 0xbf

for (i = 0xa0; i <= 0xbf; i++) {
token[i] = fix(i - 0xa0, [Link]);
}

return token;
}

function constant(value) {
return function() {
return value;
};
}

function flex(lenFunc, decodeFunc) {

return function(decoder) {
var len = lenFunc(decoder);
return decodeFunc(decoder, len);
};
}

function fix(len, method) {

return function(decoder) {
return method(decoder, len);
};
}

/***/ }),

// [Link]

var ExtBuffer = __webpack_require__(/! ./ext-buffer /

"./node_modules/msgpack-lite/lib/[Link]").ExtBuffer;
var ExtPacker = __webpack_require__(/*! ./ext-packer */
"./node_modules/msgpack-lite/lib/[Link]");
var WriteType = __webpack_require__(/*! ./write-type */
"./node_modules/msgpack-lite/lib/[Link]");
var CodecBase = __webpack_require__(/*! ./codec-base */
"./node_modules/msgpack-lite/lib/[Link]");

[Link]({
addExtPacker: addExtPacker,
getExtPacker: getExtPacker,
init: init
});

[Link] = [Link]([Link]);

function getEncoder(options) {
var writeType = [Link](options);
return encode;

function encode(encoder, value) {

var func = writeType[typeof value];
if (!func) throw new Error("Unsupported type \"" + (typeof value) +
"\": " + value);
func(encoder, value);
}
}

function init() {
var options = [Link];
[Link] = getEncoder(options);

if (options && [Link]) {

[Link](this);
}

return this;
}

function addExtPacker(etype, Class, packer) {

packer = [Link](packer);
var name = [Link];
if (name && name !== "Object") {
var packers = [Link] || ([Link] = {});
packers[name] = extPacker;
} else {
// fallback for IE
var list = [Link] || ([Link] = []);
[Link]([Class, extPacker]);
}

function extPacker(value) {
if (packer) value = packer(value);
return new ExtBuffer(value, etype);
}
}

function getExtPacker(value) {
var packers = [Link] || ([Link] = {});
var c = [Link];
var e = c && [Link] && packers[[Link]];
if (e) return e;

// fallback for IE
var list = [Link] || ([Link] = []);
var len = [Link];
for (var i = 0; i < len; i++) {
var pair = list[i];
if (c === pair[0]) return pair[1];
}
}

/***/ }),

// [Link]

var ieee754 = __webpack_require__(/! ieee754 /

var uint8 = __webpack_require__(/! ./write-uint8 /

"./node_modules/msgpack-lite/lib/[Link]").uint8;
var Bufferish = __webpack_require__(/*! ./bufferish */
"./node_modules/msgpack-lite/lib/[Link]");
var Buffer = [Link];
var IS_BUFFER_SHIM = [Link] && ("TYPED_ARRAY_SUPPORT" in
Buffer);
var NO_TYPED_ARRAY = IS_BUFFER_SHIM && !Buffer.TYPED_ARRAY_SUPPORT;
var Buffer_prototype = [Link] && [Link] || {};
[Link] = getWriteToken;

function init_uint8array() {
var token = init_token();

// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = writeN(0xca, 4, writeFloatBE);
token[0xcb] = writeN(0xcb, 8, writeDoubleBE);

return token;
}

// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
token[0xc4] = write1(0xc4);
token[0xc5] = write2(0xc5);
token[0xc6] = write4(0xc6);

// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
token[0xc7] = write1(0xc7);
token[0xc8] = write2(0xc8);
token[0xc9] = write4(0xc9);

// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = writeN(0xca, 4, (Buffer_prototype.writeFloatBE ||
writeFloatBE), true);
token[0xcb] = writeN(0xcb, 8, (Buffer_prototype.writeDoubleBE ||
writeDoubleBE), true);

// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
token[0xcc] = write1(0xcc);
token[0xcd] = write2(0xcd);
token[0xce] = write4(0xce);
token[0xcf] = writeN(0xcf, 8, writeUInt64BE);

// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
token[0xd0] = write1(0xd0);
token[0xd1] = write2(0xd1);
token[0xd2] = write4(0xd2);
token[0xd3] = writeN(0xd3, 8, writeInt64BE);

// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
token[0xd9] = write1(0xd9);
token[0xda] = write2(0xda);
token[0xdb] = write4(0xdb);

// array 16 -- 0xdc
// array 32 -- 0xdd
token[0xdc] = write2(0xdc);
token[0xdd] = write4(0xdd);

// map 16 -- 0xde
// map 32 -- 0xdf
token[0xde] = write2(0xde);
token[0xdf] = write4(0xdf);

return token;
}

// safe mode: for old browsers and who needs asserts

function init_safe() {
// (immediate values)
// positive fixint -- 0x00 - 0x7f
// nil -- 0xc0
// false -- 0xc2
// true -- 0xc3
// negative fixint -- 0xe0 - 0xff
var token = [Link]();

// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
token[0xc4] = writeN(0xc4, 1, [Link].writeUInt8);
token[0xc5] = writeN(0xc5, 2, [Link].writeUInt16BE);
token[0xc6] = writeN(0xc6, 4, [Link].writeUInt32BE);

// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
token[0xc7] = writeN(0xc7, 1, [Link].writeUInt8);
token[0xc8] = writeN(0xc8, 2, [Link].writeUInt16BE);
token[0xc9] = writeN(0xc9, 4, [Link].writeUInt32BE);

// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = writeN(0xca, 4, [Link]);
token[0xcb] = writeN(0xcb, 8, [Link]);

// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
token[0xcc] = writeN(0xcc, 1, [Link].writeUInt8);
token[0xcd] = writeN(0xcd, 2, [Link].writeUInt16BE);
token[0xce] = writeN(0xce, 4, [Link].writeUInt32BE);
token[0xcf] = writeN(0xcf, 8, writeUInt64BE);

// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
token[0xd0] = writeN(0xd0, 1, [Link].writeInt8);
token[0xd1] = writeN(0xd1, 2, [Link].writeInt16BE);
token[0xd2] = writeN(0xd2, 4, [Link].writeInt32BE);
token[0xd3] = writeN(0xd3, 8, writeInt64BE);

// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
token[0xd9] = writeN(0xd9, 1, [Link].writeUInt8);
token[0xda] = writeN(0xda, 2, [Link].writeUInt16BE);
token[0xdb] = writeN(0xdb, 4, [Link].writeUInt32BE);

// array 16 -- 0xdc
// array 32 -- 0xdd
token[0xdc] = writeN(0xdc, 2, [Link].writeUInt16BE);
token[0xdd] = writeN(0xdd, 4, [Link].writeUInt32BE);

// map 16 -- 0xde
// map 32 -- 0xdf
token[0xde] = writeN(0xde, 2, [Link].writeUInt16BE);
token[0xdf] = writeN(0xdf, 4, [Link].writeUInt32BE);

return token;
}

function write1(type) {
return function(encoder, value) {
var offset = [Link](2);
var buffer = [Link];
buffer[offset++] = type;
buffer[offset] = value;
};
}

function write2(type) {
return function(encoder, value) {
var offset = [Link](3);
var buffer = [Link];
buffer[offset++] = type;
buffer[offset++] = value >>> 8;
buffer[offset] = value;
};
}

function write4(type) {
return function(encoder, value) {
var offset = [Link](5);
var buffer = [Link];
buffer[offset++] = type;
buffer[offset++] = value >>> 24;
buffer[offset++] = value >>> 16;
buffer[offset++] = value >>> 8;
buffer[offset] = value;
};
}

function writeN(type, len, method, noAssert) {

return function(encoder, value) {
var offset = [Link](len + 1);
[Link][offset++] = type;
[Link]([Link], value, offset, noAssert);
};
}

function writeUInt64BE(value, offset) {

new Uint64BE(this, offset, value);
}

function writeInt64BE(value, offset) {

new Int64BE(this, offset, value);
}

function writeFloatBE(value, offset) {

[Link](this, value, offset, false, 23, 4);
}

function writeDoubleBE(value, offset) {

[Link](this, value, offset, false, 52, 8);
}

/***/ }),

// [Link]

var IS_ARRAY = __webpack_require__(/! isarray / "./node_modules/msgpack-

lite/node_modules/isarray/[Link]");
var Int64Buffer = __webpack_require__(/*! int64-buffer */
"./node_modules/int64-buffer/[Link]");
var Uint64BE = Int64Buffer.Uint64BE;
var Int64BE = Int64Buffer.Int64BE;
var Bufferish = __webpack_require__(/*! ./bufferish */
"./node_modules/msgpack-lite/lib/[Link]");
var BufferProto = __webpack_require__(/*! ./bufferish-proto */
"./node_modules/msgpack-lite/lib/[Link]");
var WriteToken = __webpack_require__(/*! ./write-token */
"./node_modules/msgpack-lite/lib/[Link]");
var uint8 = __webpack_require__(/*! ./write-uint8 */
"./node_modules/msgpack-lite/lib/[Link]").uint8;
var ExtBuffer = __webpack_require__(/*! ./ext-buffer */
"./node_modules/msgpack-lite/lib/[Link]").ExtBuffer;

var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);

var HAS_MAP = ("undefined" !== typeof Map);

var extmap = [];

extmap[1] = 0xd4;
extmap[2] = 0xd5;
extmap[4] = 0xd6;
extmap[8] = 0xd7;
extmap[16] = 0xd8;

[Link] = getWriteType;

function getWriteType(options) {
var token = [Link](options);
var useraw = options && [Link];
var binarraybuffer = HAS_UINT8ARRAY && options &&
[Link];
var isBuffer = binarraybuffer ? [Link] :
[Link];
var bin = binarraybuffer ? bin_arraybuffer : bin_buffer;
var usemap = HAS_MAP && options && [Link];
var map = usemap ? map_to_map : obj_to_map;

var writeType = {
"boolean": bool,
"function": nil,
"number": number,
"object": (useraw ? object_raw : object),
"string": _string(useraw ? raw_head_size : str_head_size),
"symbol": nil,
"undefined": nil
};

return writeType;

// false -- 0xc2
// true -- 0xc3
function bool(encoder, value) {
var type = value ? 0xc3 : 0xc2;
token[type](encoder, value);
}

function number(encoder, value) {

// uint 64 -- 0xcf
function uint64(encoder, value) {
var type = 0xcf;
token[type](encoder, [Link]());
}

// int 64 -- 0xd3
function int64(encoder, value) {
var type = 0xd3;
token[type](encoder, [Link]());
}

// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
// fixstr -- 0xa0 - 0xbf
function str_head_size(length) {
return (length < 32) ? 1 : (length <= 0xFF) ? 2 : (length <=
0xFFFF) ? 3 : 5;
}

// raw 16 -- 0xda
// raw 32 -- 0xdb
// fixraw -- 0xa0 - 0xbf
function raw_head_size(length) {
return (length < 32) ? 1 : (length <= 0xFFFF) ? 3 : 5;
}

function _string(head_size) {
return string;

function string(encoder, value) {

// prepare buffer
var length = [Link];
var maxsize = 5 + length * 3;
[Link] = [Link](maxsize);
var buffer = [Link];

// expected header size

var expected = head_size(length);

// expected start point

var start = [Link] + expected;

// write string
length = [Link](buffer, value, start);

// actual header size

var actual = head_size(length);

// move content when needed

if (expected !== actual) {
var targetStart = start + actual - expected;
var end = start + length;
[Link](buffer, buffer, targetStart, start,
end);
}

// write header
var type = (actual === 1) ? (0xa0 + length) : (actual <= 3) ?
(0xd7 + actual) : 0xdb;
token[type](encoder, length);

// move cursor
[Link] += length;
}
}

function object(encoder, value) {

// null
if (value === null) return nil(encoder, value);

// Buffer
if (isBuffer(value)) return bin(encoder, value);

// Array
if (IS_ARRAY(value)) return array(encoder, value);

// int64-buffer objects
if (Uint64BE.isUint64BE(value)) return uint64(encoder, value);
if (Int64BE.isInt64BE(value)) return int64(encoder, value);

// ext formats
var packer = [Link](value);
if (packer) value = packer(value);
if (value instanceof ExtBuffer) return ext(encoder, value);

// plain old Objects or Map

map(encoder, value);
}

function object_raw(encoder, value) {

// Buffer
if (isBuffer(value)) return raw(encoder, value);
// others
object(encoder, value);
}

// nil -- 0xc0
function nil(encoder, value) {
var type = 0xc0;
token[type](encoder, value);
}

// fixarray -- 0x90 - 0x9f

// array 16 -- 0xdc
// array 32 -- 0xdd
function array(encoder, value) {
var length = [Link];
var type = (length < 16) ? (0x90 + length) : (length <= 0xFFFF) ?
0xdc : 0xdd;
token[type](encoder, length);

var encode = [Link];

for (var i = 0; i < length; i++) {
encode(encoder, value[i]);
}
}

// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
function bin_buffer(encoder, value) {
var length = [Link];
var type = (length < 0xFF) ? 0xc4 : (length <= 0xFFFF) ? 0xc5 :
0xc6;
token[type](encoder, length);
[Link](value);
}

function bin_arraybuffer(encoder, value) {

bin_buffer(encoder, new Uint8Array(value));
}

// fixext 1 -- 0xd4
// fixext 2 -- 0xd5
// fixext 4 -- 0xd6
// fixext 8 -- 0xd7
// fixext 16 -- 0xd8
// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
function ext(encoder, value) {
var buffer = [Link];
var length = [Link];
var type = extmap[length] || ((length < 0xFF) ? 0xc7 : (length <=
0xFFFF) ? 0xc8 : 0xc9);
token[type](encoder, length);
uint8[[Link]](encoder);
[Link](buffer);
}

// fixmap -- 0x80 - 0x8f

// map 16 -- 0xde
// map 32 -- 0xdf
function obj_to_map(encoder, value) {
var keys = [Link](value);
var length = [Link];
var type = (length < 16) ? (0x80 + length) : (length <= 0xFFFF) ?
0xde : 0xdf;
token[type](encoder, length);

var encode = [Link];

[Link](function(key) {
encode(encoder, key);
encode(encoder, value[key]);
});
}

// fixmap -- 0x80 - 0x8f

// map 16 -- 0xde
// map 32 -- 0xdf
function map_to_map(encoder, value) {
if (!(value instanceof Map)) return obj_to_map(encoder, value);

var length = [Link];

var type = (length < 16) ? (0x80 + length) : (length <= 0xFFFF) ?
0xde : 0xdf;
token[type](encoder, length);

var encode = [Link];

[Link](function(val, key, m) {
encode(encoder, key);
encode(encoder, val);
});
}

// raw 16 -- 0xda
// raw 32 -- 0xdb
// fixraw -- 0xa0 - 0xbf
function raw(encoder, value) {
var length = [Link];
var type = (length < 32) ? (0xa0 + length) : (length <= 0xFFFF) ?
0xda : 0xdb;
token[type](encoder, length);
[Link](value);
}
}

/***/ }),

// [Link]

var constant = exports.uint8 = new Array(256);

for (var i = 0x00; i <= 0xFF; i++) {
constant[i] = write0(i);
}

function write0(type) {
return function(encoder) {
var offset = [Link](1);
[Link][offset] = type;
};
}

/***/ }),

/***/ "./node_modules/msgpack-lite/node_modules/isarray/[Link]":
/*!*****************************************************************!*\
!*** ./node_modules/msgpack-lite/node_modules/isarray/[Link] ***!
\*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var toString = {}.toString;

[Link] = [Link] || function (arr) {

return [Link](arr) == '[object Array]';
};

/***/ }),

/***/ "./node_modules/process/[Link]":
/*!*****************************************!*\
!*** ./node_modules/process/[Link] ***!
\*****************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// shim for using process in browser

var process = [Link] = {};

// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's
inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout)
&& clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E.
maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E.
doesn't trust the global object when called normally
return [Link](null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have
the global object for 'this', hopfully our context correct otherwise it will throw
a global error.
// Some versions of I.E. have different rules for clearTimeout
vs setTimeout
return [Link](this, marker);
}
}

}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if ([Link]) {
queue = [Link](queue);
} else {
queueIndex = -1;
}
if ([Link]) {
drainQueue();
}
}

function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;

// v8 likes predictible objects

function noop() {}

[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;
[Link] = noop;

[Link] = function (name) { return [] }

[Link] = function (name) {

throw new Error('[Link] is not supported');
};

[Link] = function () { return '/' };

[Link] = function (dir) {
throw new Error('[Link] is not supported');
};
[Link] = function() { return 0; };
/***/ }),

/***/ "./node_modules/punycode/[Link]":
/*!*******************************************!*\
!*** ./node_modules/punycode/[Link] ***!
\*******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module, global) {var

__WEBPACK_AMD_DEFINE_RESULT__;/*! [Link] v1.4.1 by @mathias */
;(function(root) {

/** Detect free

variables */
var freeExports =
true && exports &&
!
[Link] && exports;
var freeModule =
true && module &&
!
[Link] && module;
var freeGlobal =
typeof global == 'object' && global;
if (

[Link] === freeGlobal ||

[Link] === freeGlobal

) {
root =
freeGlobal;
}

/**
* The `punycode` object.
* @name punycode
* @type Object
*/
var punycode,

/** Highest
positive signed 32-bit float value */
maxInt =
2147483647, // aka. 0x7FFFFFFF or 2^31-1

/**
Bootstring parameters */
base = 36,
tMin = 1,
tMax = 26,
skew = 38,
damp = 700,
initialBias =
72,
initialN =
128, // 0x80
delimiter =
'-', // '\x2D'

/** Regular
expressions */
regexPunycode
= /^xn--/,
regexNonASCII
= /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars

regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

/** Error
messages */
errors = {

'overflow': 'Overflow: input needs wider integers to process',

'not-
basic': 'Illegal input >= 0x80 (not a basic code point)',
'invalid-
input': 'Invalid input'
},

/**
Convenience shortcuts */
baseMinusTMin
= base - tMin,
floor =
[Link],

stringFromCharCode = [Link],

/** Temporary
variable */
key;

/*--------------------------------------------------------------------------*/

/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function
error(type) {
throw new
RangeError(errors[type]);
}

/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function
map(array, fn) {
var length =
[Link];
var result =
[];
while
(length--) {

result[length] = fn(array[length]);
}
return
result;
}

/**
* A simple `Array#map`-like wrapper to work with domain name strings or
email
* addresses.
* @private
* @param {String} domain The domain name or email address.
* @param {Function} callback The function that gets called for every
* character.
* @returns {Array} A new string of characters returned by the callback
* function.
*/
function
mapDomain(string, fn) {
var parts =
[Link]('@');
var result =
'';
if
([Link] > 1) {
// In
email addresses, only the domain name should be punycoded. Leave
// the
local part (i.e. everything up to `@`) intact.
result =
parts[0] + '@';
string =
parts[1];
}
// Avoid
`split(regex)` for IE8 compatibility. See #17.
string =
[Link](regexSeparators, '\x2E');
var labels =
[Link]('.');
var encoded =
map(labels, fn).join('.');
return result
+ encoded;
}

/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
* @see `[Link]`
* @see <[Link]
* @memberOf punycode.ucs2
* @name decode
* @param {String} string The Unicode input string (UCS-2).
* @returns {Array} The new array of code points.
*/
function
ucs2decode(string) {
var output =
[],
counter =
0,
length =
[Link],
value,
extra;
while
(counter < length) {
value =
[Link](counter++);
if (value
>= 0xD800 && value <= 0xDBFF && counter < length) {
//
high surrogate, and there is a next character
extra
= [Link](counter++);
if
((extra & 0xFC00) == 0xDC00) { // low surrogate

[Link](((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);

}
else {
/
/ unmatched surrogate; only append this code unit, in case the next
/
/ code unit is the high surrogate of a surrogate pair

[Link](value);

counter--;
}
} else {

[Link](value);
}
}
return
output;
}

/**
* Creates a string based on an array of numeric code points.
* @see `[Link]`
* @memberOf punycode.ucs2
* @name encode
* @param {Array} codePoints The array of numeric code points.
* @returns {String} The new Unicode string (UCS-2).
*/
function
ucs2encode(array) {
return
map(array, function(value) {
var
output = '';
if (value
> 0xFFFF) {
value
-= 0x10000;

output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);

value
= 0xDC00 | value & 0x3FF;
}
output +=
stringFromCharCode(value);
return
output;
}).join('');
}

/**
* Converts a basic code point into a digit/integer.
* @see `digitToBasic()`
* @private
* @param {Number} codePoint The basic numeric code point value.
* @returns {Number} The numeric value of a basic code point (for use in
* representing integers) in the range `0` to `base - 1`, or `base` if
* the code point does not represent a value.
*/
function
basicToDigit(codePoint) {
if (codePoint
- 48 < 10) {
return
codePoint - 22;
}
if (codePoint
- 65 < 26) {
return
codePoint - 65;
}
if (codePoint
- 97 < 26) {
return
codePoint - 97;
}
return base;
}

/**
* Converts a digit/integer into a basic code point.
* @see `basicToDigit()`
* @private
* @param {Number} digit The numeric value of a basic code point.
* @returns {Number} The basic code point whose value (when used for
* representing integers) is `digit`, which needs to be in the range
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
* used; else, the lowercase form is used. The behavior is undefined
* if `flag` is non-zero and `digit` has no uppercase form.
*/
function
digitToBasic(digit, flag) {
// 0..25 map
to ASCII a..z or A..Z
// 26..35 map
to ASCII 0..9
return digit
+ 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}

/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* [Link]
* @private
*/
function
adapt(delta, numPoints, firstTime) {
var k = 0;
delta =
firstTime ? floor(delta / damp) : delta >> 1;
delta +=
floor(delta / numPoints);
for (/* no
initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
delta =
floor(delta / baseMinusTMin);
}
return
floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
}

/**
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
* symbols.
* @memberOf punycode
* @param {String} input The Punycode string of ASCII-only symbols.
* @returns {String} The resulting string of Unicode symbols.
*/
function
decode(input) {
// Don't use
UCS-2
var output =
[],

inputLength = [Link],
out,
i = 0,
n =
initialN,
bias =
initialBias,
basic,
j,
index,
oldi,
w,
k,
digit,
t,
/**
Cached calculation results */

baseMinusT;

// Handle the
basic code points: let `basic` be the number of input code
// points
before the last delimiter, or `0` if there is none, then copy
// the first
basic code points to the output.

basic =
[Link](delimiter);
if (basic <
0) {
basic =
0;
}

for (j = 0; j
< basic; ++j) {
// if
it's not a basic code point
if
([Link](j) >= 0x80) {

error('not-basic');
}

[Link]([Link](j));
}

// Main
decoding loop: start just after the last delimiter if any basic code
// points
were copied; start at the beginning otherwise.

for (index =
basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {

//
ìndex` is the index of the next character to be consumed.
// Decode
a generalized variable-length integer into `delta`,
// which
gets added to ì`. The overflow checking is easier
// if we
increase ì` as we go, then subtract off its starting
// value
at the end to obtain `delta`.
for (oldi
= i, w = 1, k = base; /* no condition */; k += base) {

if
(index >= inputLength) {

error('invalid-input');
}

digit
= basicToDigit([Link](index++));

if
(digit >= base || digit > floor((maxInt - i) / w)) {

error('overflow');
}

i +=
digit * w;
t = k
<= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

if
(digit < t) {

break;
}

baseMinusT = base - t;
if (w
> floor(maxInt / baseMinusT)) {

error('overflow');
}

w *=
baseMinusT;

out =
[Link] + 1;
bias =
adapt(i - oldi, out, oldi == 0);

// `i`
was supposed to wrap around from `out` to `0`,
//
incrementing `n` each time, so we'll fix that now:
if
(floor(i / out) > maxInt - n) {

error('overflow');
}

n +=
floor(i / out);
i %= out;
// Insert
`n` at position `i` of the output

[Link](i++, 0, n);

return
ucs2encode(output);
}

/**
* Converts a string of Unicode symbols (e.g. a domain name label) to a
* Punycode string of ASCII-only symbols.
* @memberOf punycode
* @param {String} input The string of Unicode symbols.
* @returns {String} The resulting Punycode string of ASCII-only symbols.
*/
function
encode(input) {
var n,
delta,

handledCPCount,

basicLength,
bias,
j,
m,
q,
k,
t,

currentValue,
output =
[],
/**
`inputLength` will hold the number of code points in `input`. */

inputLength,
/**
Cached calculation results */

handledCPCountPlusOne,

baseMinusT,
qMinusT;

// Convert
the input in UCS-2 to Unicode
input =
ucs2decode(input);

// Cache the
length
inputLength =
[Link];
// Initialize
the state
n = initialN;
delta = 0;
bias =
initialBias;

// Handle the
basic code points
for (j = 0; j
< inputLength; ++j) {

currentValue = input[j];
if
(currentValue < 0x80) {

[Link](stringFromCharCode(currentValue));
}
}

handledCPCount = basicLength = [Link];

//
`handledCPCount` is the number of code points that have been handled;
//
`basicLength` is the number of basic code points.

// Finish the
basic string - if it is not empty - with a delimiter
if
(basicLength) {

[Link](delimiter);
}

// Main
encoding loop:
while
(handledCPCount < inputLength) {

// All
non-basic code points < n have been handled already. Find the next
// larger
one:
for (m =
maxInt, j = 0; j < inputLength; ++j) {

currentValue = input[j];
if
(currentValue >= n && currentValue < m) {
m
= currentValue;
}
}

//
Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
// but
guard against overflow

handledCPCountPlusOne = handledCPCount + 1;
if (m - n
> floor((maxInt - delta) / handledCPCountPlusOne)) {

error('overflow');
}

delta +=
(m - n) * handledCPCountPlusOne;
n = m;

for (j =
0; j < inputLength; ++j) {

currentValue = input[j];

if
(currentValue < n && ++delta > maxInt) {

error('overflow');
}

if
(currentValue == n) {
/
/ Represent delta as a generalized variable-length integer

for (q = delta, k = base; /* no condition */; k += base) {

t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

if (q < t) {

break;

qMinusT = q - t;

baseMinusT = base - t;

[Link](

stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))

);

q = floor(qMinusT / baseMinusT);
}

[Link](stringFromCharCode(digitToBasic(q, 0)));

bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);

delta = 0;
+
+handledCPCount;
}
}

++delta;
++n;

}
return
[Link]('');
}

/**
* Converts a Punycode string representing a domain name or an email address
* to Unicode. Only the Punycoded parts of the input will be converted, i.e.
* it doesn't matter if you call it on a string that has already been
* converted to Unicode.
* @memberOf punycode
* @param {String} input The Punycoded domain name or email address to
* convert to Unicode.
* @returns {String} The Unicode representation of the given Punycode
* string.
*/
function
toUnicode(input) {
return
mapDomain(input, function(string) {
return
[Link](string)
?
decode([Link](4).toLowerCase())
: string;
});
}

/**
* Converts a Unicode string representing a domain name or an email address
to
* Punycode. Only the non-ASCII parts of the domain name will be converted,
* i.e. it doesn't matter if you call it with a domain that's already in
* ASCII.
* @memberOf punycode
* @param {String} input The domain name or email address to convert, as a
* Unicode string.
* @returns {String} The Punycode representation of the given domain name or
* email address.
*/
function
toASCII(input) {
return
mapDomain(input, function(string) {
return
[Link](string)
?
'xn--' + encode(string)
: string;
});
}
/*--------------------------------------------------------------------------*/

/** Define the

public API */
punycode = {
/**
* A string representing the current [Link] version number.
* @memberOf punycode
* @type String
*/
'version':
'1.4.1',
/**
* An object of methods to convert from JavaScript's internal character
* representation (UCS-2) to Unicode code points, and back.
* @see <[Link]
* @memberOf punycode
* @type Object
*/
'ucs2': {
'decode':
ucs2decode,
'encode':
ucs2encode
},
'decode':
decode,
'encode':
encode,
'toASCII':
toASCII,
'toUnicode':
toUnicode
};

/** Expose
`punycode` */
// Some AMD build
optimizers, like [Link], check for specific condition patterns
// like the
following:
if (
true
) {
!
(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
return
punycode;
}).call(expor
ts, __webpack_require__, exports, module),

__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && ([Link] =

__WEBPACK_AMD_DEFINE_RESULT__));
} else {}

}(this));

/* WEBPACK VAR
INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/[Link] */
"./node_modules/webpack/buildin/[Link]")(module), __webpack_require__(/*!
./../webpack/buildin/[Link] */ "./node_modules/webpack/buildin/[Link]")))

/***/ }),

/***/ "./node_modules/querystring-es3/[Link]":
/*!************************************************!*\
!*** ./node_modules/querystring-es3/[Link] ***!
\************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// If [Link] has been overridden, then calling

// [Link](prop) will break.
// See: [Link]
function hasOwnProperty(obj, prop) {
return [Link](obj, prop);
}

[Link] = function(qs, sep, eq, options) {

sep = sep || '&';
eq = eq || '=';
var obj = {};

if (typeof qs !== 'string' || [Link] === 0) {

return obj;
}

var regexp = /\+/g;

qs = [Link](sep);
var maxKeys = 1000;
if (options && typeof [Link] === 'number') {
maxKeys = [Link];
}

var len = [Link];

// maxKeys <= 0 means that we should not limit keys count
if (maxKeys > 0 && len > maxKeys) {
len = maxKeys;
}

for (var i = 0; i < len; ++i) {

var x = qs[i].replace(regexp, '%20'),
idx = [Link](eq),
kstr, vstr, k, v;

if (idx >= 0) {
kstr = [Link](0, idx);
vstr = [Link](idx + 1);
} else {
kstr = x;
vstr = '';
}

k = decodeURIComponent(kstr);
v = decodeURIComponent(vstr);

if (!hasOwnProperty(obj, k)) {
obj[k] = v;
} else if (isArray(obj[k])) {
obj[k].push(v);
} else {
obj[k] = [obj[k], v];
}
}

return obj;
};

var isArray = [Link] || function (xs) {

return [Link](xs) === '[object Array]';
};

/***/ }),

var stringifyPrimitive = function(v) {

switch (typeof v) {
case 'string':
return v;

case 'boolean':
return v ? 'true' : 'false';

case 'number':
return isFinite(v) ? v : '';

default:
return '';
}
};

[Link] = function(obj, sep, eq, name) {

sep = sep || '&';
eq = eq || '=';
if (obj === null) {
obj = undefined;
}

if (typeof obj === 'object') {

return map(objectKeys(obj), function(k) {
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
if (isArray(obj[k])) {
return map(obj[k], function(v) {
return ks + encodeURIComponent(stringifyPrimitive(v));
}).join(sep);
} else {
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
}
}).join(sep);

if (!name) return '';

return encodeURIComponent(stringifyPrimitive(name)) + eq +
encodeURIComponent(stringifyPrimitive(obj));
};

var isArray = [Link] || function (xs) {

return [Link](xs) === '[object Array]';
};

function map (xs, f) {

if ([Link]) return [Link](f);
var res = [];
for (var i = 0; i < [Link]; i++) {
[Link](f(xs[i], i));
}
return res;
}

var objectKeys = [Link] || function (obj) {

var res = [];
for (var key in obj) {
if ([Link](obj, key)) [Link](key);
}
return res;
};

/***/ }),

/***/ "./node_modules/querystring-es3/[Link]":
/*!***********************************************!*\
!*** ./node_modules/querystring-es3/[Link] ***!
\***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

[Link] = [Link] = __webpack_require__(/! ./decode /

"./node_modules/querystring-es3/[Link]");
[Link] = [Link] = __webpack_require__(/*! ./encode */
"./node_modules/querystring-es3/[Link]");

/***/ }),

/***/ "./node_modules/url/[Link]":
/*!*********************************!*\
!*** ./node_modules/url/[Link] ***!
\*********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var punycode = __webpack_require__(/! punycode /

"./node_modules/punycode/[Link]");
var util = __webpack_require__(/*! ./util */ "./node_modules/url/[Link]");

[Link] = urlParse;
[Link] = urlResolve;
[Link] = urlResolveObject;
[Link] = urlFormat;

[Link] = Url;

function Url() {
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
}

// Reference: RFC 3986, RFC 1808, RFC 2396

// define these here so at least they only have to be

// compiled once on the first module load.
var protocolPattern = /^([a-z0-9.+-]+:)/i,
portPattern = /:[0-9]*$/,

// Special case for a simple path URL

simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,

// RFC 2396: characters reserved for delimiting URLs.

// We actually just auto-escape these.
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],

// RFC 2396: characters not allowed for various reasons.

unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),

// Allowed by RFCs, but cause of XSS attacks. Always escape these.

autoEscape = ['\''].concat(unwise),
// Characters that are never ever allowed in a hostname.
// Note that any invalid chars are also handled, but these
// are the ones that are *expected* to be seen, so we fast-path
// them.
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
hostEndingChars = ['/', '?', '#'],
hostnameMaxLen = 255,
hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
// protocols that can allow "unsafe" and "unwise" chars.
unsafeProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that never have a hostname.
hostlessProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that always contain a // bit.
slashedProtocol = {
'http': true,
'https': true,
'ftp': true,
'gopher': true,
'file': true,
'http:': true,
'https:': true,
'ftp:': true,
'gopher:': true,
'file:': true
},
querystring = __webpack_require__(/*! querystring */
"./node_modules/querystring-es3/[Link]");

function urlParse(url, parseQueryString, slashesDenoteHost) {

if (url && [Link](url) && url instanceof Url) return url;

var u = new Url;

[Link](url, parseQueryString, slashesDenoteHost);
return u;
}

[Link] = function(url, parseQueryString, slashesDenoteHost) {

if (![Link](url)) {
throw new TypeError("Parameter 'url' must be a string, not " +
typeof url);
}

// Copy chrome, IE, opera backslash-handling behavior.

// Back slashes before the query string get converted to forward
slashes
// See: [Link]
var queryIndex = [Link]('?'),
splitter =
(queryIndex !== -1 && queryIndex < [Link]('#')) ? '?' : '#',
uSplit = [Link](splitter),
slashRegex = /\\/g;
uSplit[0] = uSplit[0].replace(slashRegex, '/');
url = [Link](splitter);

var rest = url;

// trim before proceeding.

// This is to support parse stuff like " [Link] \n"
rest = [Link]();

var proto = [Link](rest);

if (proto) {
proto = proto[0];
var lowerProto = [Link]();
[Link] = lowerProto;
rest = [Link]([Link]);
}

// figure out if it's got a host

// user@server is *always* interpreted as a hostname, and url
// resolution will treat //foo/bar as host=foo,path=bar because that's
// how the browser resolves relative URLs.
if (slashesDenoteHost || proto || [Link](/^\/\/[^@\/]+@[^@\/]+/)) {
var slashes = [Link](0, 2) === '//';
if (slashes && !(proto && hostlessProtocol[proto])) {
rest = [Link](2);
[Link] = true;
}
}

if (!hostlessProtocol[proto] &&
(slashes || (proto && !slashedProtocol[proto]))) {
// there's a hostname.
// the first instance of /, ?, ;, or # ends the host.
//
// If there is an @ in the hostname, then non-host chars *are*
allowed
// to the left of the last @ sign, unless some host-ending
character
// comes *before* the @-sign.
// URLs are obnoxious.
//
// ex:
// [Link] => user:a@b host:c
// [Link] => user:a host:c path:/?@c

// v0.12 TODO(isaacs): This is not quite how Chrome does things.

// Review our test case against browsers more comprehensively.

// find the first instance of any hostEndingChars

var hostEnd = -1;
for (var i = 0; i < [Link]; i++) {
var hec = [Link](hostEndingChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}

// at this point, either we have an explicit point where the

// auth portion cannot go past, or the last @ char is the decider.
var auth, atSign;
if (hostEnd === -1) {
// atSign can be anywhere.
atSign = [Link]('@');
} else {
// atSign must be in auth portion.
// [Link] => host:b auth:a path:/c@d
atSign = [Link]('@', hostEnd);
}

// Now we have a portion which is definitely the auth.

// Pull that off.
if (atSign !== -1) {
auth = [Link](0, atSign);
rest = [Link](atSign + 1);
[Link] = decodeURIComponent(auth);
}

// the host is the remaining to the left of the first non-host char
hostEnd = -1;
for (var i = 0; i < [Link]; i++) {
var hec = [Link](nonHostChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// if we still have not hit it, then the entire thing is a host.
if (hostEnd === -1)
hostEnd = [Link];

[Link] = [Link](0, hostEnd);

rest = [Link](hostEnd);
// pull out port.
[Link]();

// we've indicated that there is a hostname,

// so even if it's empty, it has to be present.
[Link] = [Link] || '';

// if hostname begins with [ and ends with ]

// assume that it's an IPv6 address.
var ipv6Hostname = [Link][0] === '[' &&
[Link][[Link] - 1] === ']';

// validate a little.
if (!ipv6Hostname) {
var hostparts = [Link](/\./);
for (var i = 0, l = [Link]; i < l; i++) {
var part = hostparts[i];
if (!part) continue;
if (![Link](hostnamePartPattern)) {
var newpart = '';
for (var j = 0, k = [Link]; j < k; j++) {
if ([Link](j) > 127) {
// we replace non-ASCII char with a temporary
placeholder
// we need this to make sure size of hostname
is not
// broken by replacing non-ASCII by nothing
newpart += 'x';
} else {
newpart += part[j];
}
}
// we test again with ASCII char only
if (![Link](hostnamePartPattern)) {
var validParts = [Link](0, i);
var notHost = [Link](i + 1);
var bit = [Link](hostnamePartStart);
if (bit) {
[Link](bit[1]);
[Link](bit[2]);
}
if ([Link]) {
rest = '/' + [Link]('.') + rest;
}
[Link] = [Link]('.');
break;
}
}
}
}

if ([Link] > hostnameMaxLen) {

[Link] = '';
} else {
// hostnames are always lower case.
[Link] = [Link]();
}
if (!ipv6Hostname) {
// IDNA Support: Returns a punycoded representation of
"domain".
// It only converts parts of the domain name that
// have non-ASCII characters, i.e. it doesn't matter if
// you call it with a domain that already is ASCII-only.
[Link] = [Link]([Link]);
}

var p = [Link] ? ':' + [Link] : '';

var h = [Link] || '';
[Link] = h + p;
[Link] += [Link];

// strip [ and ] from the hostname

// the host field still retains them, though
if (ipv6Hostname) {
[Link] = [Link](1, [Link] -
2);
if (rest[0] !== '/') {
rest = '/' + rest;
}
}
}

// now rest is set to the post-host stuff.

// chop off any delim chars.
if (!unsafeProtocol[lowerProto]) {

// First, make 100% sure that any "autoEscape" chars get

// escaped, even if encodeURIComponent doesn't think they
// need to be.
for (var i = 0, l = [Link]; i < l; i++) {
var ae = autoEscape[i];
if ([Link](ae) === -1)
continue;
var esc = encodeURIComponent(ae);
if (esc === ae) {
esc = escape(ae);
}
rest = [Link](ae).join(esc);
}
}

// chop off from the tail first.

//to support [Link]

if ([Link] || [Link]) {
var p = [Link] || '';
var s = [Link] || '';
[Link] = p + s;
}

// finally, reconstruct the href based on what has been validated.

[Link] = [Link]();
return this;
};

// format a parsed object into a url string

function urlFormat(obj) {
// ensure it's an object, and not a string url.
// If it's an obj, this is a no-op.
// this way, you can call url_format() on strings
// to clean up potentially wonky urls.
if ([Link](obj)) obj = urlParse(obj);
if (!(obj instanceof Url)) return [Link](obj);
return [Link]();
}

[Link] = function() {
var auth = [Link] || '';
if (auth) {
auth = encodeURIComponent(auth);
auth = [Link](/%3A/i, ':');
auth += '@';
}

var protocol = [Link] || '',

pathname = [Link] || '',
hash = [Link] || '',
host = false,
query = '';

if ([Link]) {
host = auth + [Link];
} else if ([Link]) {
host = auth + ([Link](':') === -1 ?
[Link] :
'[' + [Link] + ']');
if ([Link]) {
host += ':' + [Link];
}
}
if ([Link] &&
[Link]([Link]) &&
[Link]([Link]).length) {
query = [Link]([Link]);
}

var search = [Link] || (query && ('?' + query)) || '';

if (protocol && [Link](-1) !== ':') protocol += ':';

// only the slashedProtocols get the //. Not [Link] xmpp:, etc.
// unless they had them to begin with.
if ([Link] ||
(!protocol || slashedProtocol[protocol]) && host !== false) {
host = '//' + (host || '');
if (pathname && [Link](0) !== '/') pathname = '/' +
pathname;
} else if (!host) {
host = '';
}

if (hash && [Link](0) !== '#') hash = '#' + hash;

if (search && [Link](0) !== '?') search = '?' + search;

pathname = [Link](/[?#]/g, function(match) {

return encodeURIComponent(match);
});
search = [Link]('#', '%23');

return protocol + host + pathname + search + hash;

};

function urlResolve(source, relative) {

return urlParse(source, false, true).resolve(relative);
}

[Link] = function(relative) {
return [Link](urlParse(relative, false, true)).format();
};

function urlResolveObject(source, relative) {

if (!source) return relative;
return urlParse(source, false, true).resolveObject(relative);
}

[Link] = function(relative) {
if ([Link](relative)) {
var rel = new Url();
[Link](relative, false, true);
relative = rel;
}

var result = new Url();

var tkeys = [Link](this);
for (var tk = 0; tk < [Link]; tk++) {
var tkey = tkeys[tk];
result[tkey] = this[tkey];
}
// hash is always overridden, no matter what.
// even href="" will remove it.
[Link] = [Link];

// if the relative url is empty, then there's nothing left to do here.

if ([Link] === '') {
[Link] = [Link]();
return result;
}

// hrefs like //foo/bar always cut to the protocol.

if ([Link] && ![Link]) {
// take everything except the protocol from relative
var rkeys = [Link](relative);
for (var rk = 0; rk < [Link]; rk++) {
var rkey = rkeys[rk];
if (rkey !== 'protocol')
result[rkey] = relative[rkey];
}

//urlParse appends trailing / to urls like [Link]

if (slashedProtocol[[Link]] &&
[Link] && ![Link]) {
[Link] = [Link] = '/';
}

[Link] = [Link]();
return result;
}

if ([Link] && [Link] !== [Link]) {

// if it's a known url protocol, then changing
// the protocol does weird things
// first, if it's not file:, then we MUST have a host,
// and if there was a path
// to begin with, then we MUST have a path.
// if it is file:, then the host is dropped,
// because that's known to be hostless.
// anything else is assumed to be absolute.
if (!slashedProtocol[[Link]]) {
var keys = [Link](relative);
for (var v = 0; v < [Link]; v++) {
var k = keys[v];
result[k] = relative[k];
}
[Link] = [Link]();
return result;
}

[Link] = [Link];
if (![Link] && !hostlessProtocol[[Link]]) {
var relPath = ([Link] || '').split('/');
while ([Link] && !([Link] = [Link]()));
if (![Link]) [Link] = '';
if (![Link]) [Link] = '';
if (relPath[0] !== '') [Link]('');
if ([Link] < 2) [Link]('');
[Link] = [Link]('/');
} else {
[Link] = [Link];
}
[Link] = [Link];
[Link] = [Link];
[Link] = [Link] || '';
[Link] = [Link];
[Link] = [Link] || [Link];
[Link] = [Link];
// to support [Link]
if ([Link] || [Link]) {
var p = [Link] || '';
var s = [Link] || '';
[Link] = p + s;
}
[Link] = [Link] || [Link];
[Link] = [Link]();
return result;
}

// if the url is a non-slashed url, then relative

// links like ../.. should be able
// to crawl up to the hostname, as well. This is strange.
// [Link] has already been set by now.
// Later on, put the first path part into the host field.
if (psychotic) {
[Link] = '';
[Link] = null;
if ([Link]) {
if (srcPath[0] === '') srcPath[0] = [Link];
else [Link]([Link]);
}
[Link] = '';
if ([Link]) {
[Link] = null;
[Link] = null;
if ([Link]) {
if (relPath[0] === '') relPath[0] = [Link];
else [Link]([Link]);
}
[Link] = null;
}
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] ===
'');
}
if (isRelAbs) {
// it's absolute.
[Link] = ([Link] || [Link] === '') ?
[Link] : [Link];
[Link] = ([Link] || [Link] === '') ?
[Link] : [Link];
[Link] = [Link];
[Link] = [Link];
srcPath = relPath;
// fall through to the dot-handling below.
} else if ([Link]) {
// it's relative
// throw away the existing file, and take the new path instead.
if (!srcPath) srcPath = [];
[Link]();
srcPath = [Link](relPath);
[Link] = [Link];
[Link] = [Link];
} else if (![Link]([Link])) {
// just pull out the search.
// like href='?foo'.
// Put this after the other two cases because it simplifies the
booleans
if (psychotic) {
[Link] = [Link] = [Link]();
//occationaly the auth can get stuck only in host
//this especially happens in cases like
//[Link]('[Link] 'local2@domain2')
var authInHost = [Link] && [Link]('@') > 0 ?
[Link]('@') : false;
if (authInHost) {
[Link] = [Link]();
[Link] = [Link] = [Link]();
}
}
[Link] = [Link];
[Link] = [Link];
//to support [Link]
if (![Link]([Link]) || ![Link]([Link])) {
[Link] = ([Link] ? [Link] : '') +
([Link] ? [Link] : '');
}
[Link] = [Link]();
return result;
}

if (![Link]) {
// no path at all. easy.
// we've already handled the other stuff above.
[Link] = null;
//to support [Link]
if ([Link]) {
[Link] = '/' + [Link];
} else {
[Link] = null;
}
[Link] = [Link]();
return result;
}
// if a url ENDs in . or .., then it must get a trailing slash.
// however, if it ends in anything else non-slashy,
// then it must NOT get a trailing slash.
var last = [Link](-1)[0];
var hasTrailingSlash = (
([Link] || [Link] || [Link] > 1) &&
(last === '.' || last === '..') || last === '');

// strip single dots, resolve double dots to parent dir

// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = [Link]; i >= 0; i--) {
last = srcPath[i];
if (last === '.') {
[Link](i, 1);
} else if (last === '..') {
[Link](i, 1);
up++;
} else if (up) {
[Link](i, 1);
up--;
}
}

// if the path is allowed to go above the root, restore leading ..s

if (!mustEndAbs && !removeAllDots) {
for (; up--; up) {
[Link]('..');
}
}

if (mustEndAbs && srcPath[0] !== '' &&

(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
[Link]('');
}

if (hasTrailingSlash && ([Link]('/').substr(-1) !== '/')) {

[Link]('');
}

var isAbsolute = srcPath[0] === '' ||

(srcPath[0] && srcPath[0].charAt(0) === '/');

// put the host back

if (psychotic) {
[Link] = [Link] = isAbsolute ? '' :
[Link] ? [Link]() : '';
//occationaly the auth can get stuck only in host
//this especially happens in cases like
//[Link]('[Link] 'local2@domain2')
var authInHost = [Link] && [Link]('@') > 0 ?
[Link]('@') : false;
if (authInHost) {
[Link] = [Link]();
[Link] = [Link] = [Link]();
}
}
mustEndAbs = mustEndAbs || ([Link] && [Link]);

if (mustEndAbs && !isAbsolute) {

[Link]('');
}

if (![Link]) {
[Link] = null;
[Link] = null;
} else {
[Link] = [Link]('/');
}

[Link] = function() {
var host = [Link];
var port = [Link](host);
if (port) {
port = port[0];
if (port !== ':') {
[Link] = [Link](1);
}
host = [Link](0, [Link] - [Link]);
}
if (host) [Link] = host;
};

/***/ }),

/***/ "./node_modules/url/[Link]":
/*!**********************************!*\
!*** ./node_modules/url/[Link] ***!
\**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

[Link] = {
isString: function(arg) {
return typeof(arg) === 'string';
},
isObject: function(arg) {
return typeof(arg) === 'object' && arg !== null;
},
isNull: function(arg) {
return arg === null;
},
isNullOrUndefined: function(arg) {
return arg == null;
}
};

/***/ }),

/***/ "./node_modules/webpack/buildin/[Link]":
/*!***********************************!*\
!*** (webpack)/buildin/[Link] ***!
\***********************************/
/*! no static exports found */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode

g = (function() {
return this;
})();

try {
// This works if eval is allowed (see CSP)
g = g || new Function("return this")();
} catch (e) {
// This works if the window reference is available
if (typeof window === "object") g = window;
}

// g can still be undefined, but nothing to do about it...

// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

[Link] = g;

/***/ }),

[Link] = function(module) {
if (![Link]) {
[Link] = function() {};
[Link] = [];
// [Link] = undefined by default
if (![Link]) [Link] = [];
[Link](module, "loaded", {
enumerable: true,
get: function() {
return module.l;
}
});
[Link](module, "A", {
enumerable: true,
get: function() {
return module.i;
}
});
[Link] = 1;
}
return module;
};

/***/ }),

/***/ "./src/js/[Link]":
/*!***********************!*\
!*** ./src/js/[Link] ***!
\***********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

[Link] = true;

// ENV:
var isProd = [Link] !== "[Link]" && !
[Link]("192.168.");

// IMPORTS:
__webpack_require__(/*! ./libs/[Link] */
"./src/js/libs/[Link]");
var io = __webpack_require__(/*! ./libs/[Link] */ "./src/js/libs/io-
[Link]");
var UTILS = __webpack_require__(/*! ./libs/[Link] */
"./src/js/libs/[Link]");
var animText = __webpack_require__(/*! ./libs/[Link] */
"./src/js/libs/[Link]");
var config = __webpack_require__(/*! ./[Link] */ "./src/js/[Link]");
var GameObject = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var items = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var MapManager = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var ObjectManager = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var Player = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var store = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var Projectile = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var ProjectileManager = __webpack_require__(/*! ./data/[Link]
*/ "./src/js/data/[Link]");
var SoundManager = __webpack_require__(/*! ./libs/[Link] */
"./src/js/libs/[Link]").obj;
var textManager = new [Link]();
// URL PARAMS:
function getParameterByName(name, url) {
if (!url) {
url = [Link];
}
name = [Link](/[\[\]]/g, "\\$&");
var regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"),
results = [Link](url);
if (!results) return null;
if (!results[2]) return '';
return decodeURIComponent(results[2].replace(/\+/g, " "));
}

// SOCKET & CONNECTION:

var connected = false;
var startedConnecting = false;

[Link] = [Link];
[Link] = class {
constructor(wsAddr) {
if(!wsAddress){
wsAddress = wsAddr;
}

connectSocket(wsAddr);
};
}
function connectSocket(wsAddress) {
// CONNECT:
[Link](wsAddress, function(error) {
pingSocket();
setInterval(() => pingSocket(), 2500);

if (error) {
disconnect(error);
} else {
connected = true;
startGame();

// DEFINE ENTER GAME BUTTON ON CLICK:

[Link] = [Link](function() {
// START GAME:
enterGame();
});
[Link](enterGameButton);
}
}, {
"A": setInitData,
"B": disconnect,
"C": setupGame,
"D": addPlayer,
"E": removePlayer,
"a": updatePlayers,
"G": updateLeaderboard,
"H": loadGameObject,
"I": loadAI,
"J": animateAI,
"K": gatherAnimation,
"L": wiggleGameObject,
"M": shootTurret,
"N": updatePlayerValue,
"O": updateHealth,
"P": killPlayer,
"Q": killObject,
"R": killObjects,
"S": updateItemCounts,
"T": updateAge,
"U": updateUpgrades,
"V": updateItems,
"X": addProjectile,
"Y": remProjectile,
"Z": serverShutdownNotice,
"g": addAlliance,
"1": deleteAlliance,
"2": allianceNotification,
"3": setPlayerTeam,
"4": setAlliancePlayers,
"5": updateStoreItems,
"6": receiveChat,
"7": updateMinimap,
"8": showText,
"9": pingMap,
"0": pingSocketResponse
});
}
function socketReady() {
return ([Link]);
}

function joinParty() {
var currentKey = [Link];
var key = prompt("party key", currentKey);
if (key) {
[Link] = undefined; // Don't ask to leave
[Link] = "/?server=" + key;
}
} /**/

// SOUND:
var Sound = new SoundManager(config, UTILS);
function toggleSound(active) {
if (active == undefined)
active = ![Link];
[Link] = active;
//[Link]("menu", !active);
saveVal("moo_moosic", active?1:0);
}

// MATHS:
var mathPI = [Link];
var mathPI2 = mathPI * 2;
var mathPI3 = mathPI * 3;
[Link] = function (value1, value2, amount) {
var difference = [Link](value2 - value1);
if (difference > mathPI) {
if (value1 > value2) {
value2 += mathPI2;
} else {
value1 += mathPI2;
}
}
var value = (value2 + ((value1 - value2) * amount));
if (value >= 0 && value <= mathPI2)
return value;
return (value % mathPI2);
}

// REOUNDED RECTANGLE:
[Link] = function (x, y, w, h, r) {
if (w < 2 * r) r = w / 2;
if (h < 2 * r) r = h / 2;
if (r < 0)
r = 0;
[Link]();
[Link](x+r, y);
[Link](x+w, y, x+w, y+h, r);
[Link](x+w, y+h, x, y+h, r);
[Link](x, y+h, x, y, r);
[Link](x, y, x+w, y, r);
[Link]();
return this;
}

// STORAGE:
var canStore;
if (typeof(Storage) !== "undefined") {
canStore = true;
}
function saveVal(name, val) {
if (canStore)
[Link](name, val);
}
function deleteVal(name) {
if (canStore)
[Link](name);
}
function getSavedVal(name) {
if (canStore)
return [Link](name);
return null;
}

// TERMS:

// GLOBAL VALUES:
var moofoll = getSavedVal("moofoll");
function follmoo() {
if (!moofoll) {
moofoll = true;
saveVal("moofoll", 1);
}
}
var useNativeResolution;
var showPing;
var playSound;
var pixelDensity = 1;
var delta, now, lastSent;
var lastUpdate = [Link]();
var keys, attackState;
var ais = [];
var players = [];
var alliances = [];
var gameObjects = [];
var projectiles = [];
var projectileManager = new ProjectileManager(Projectile, projectiles,
players, ais, objectManager, items, config, UTILS);
var AiManager = __webpack_require__(/*! ./data/[Link] */
"./src/js/data/[Link]");
var AI = __webpack_require__(/*! ./data/[Link] */ "./src/js/data/[Link]");
var aiManager = new AiManager(ais, AI, players, items, null, config,
UTILS);
var myPlayer, myPlayerSID, tmpObj;
var waterMult = 1;
var waterPlus = 0;
var mouseX = 0;
var mouseY = 0;
var controllingTouch = {
id: -1,
startX: 0,
startY: 0,
currentX: 0,
currentY: 0
};
var attackingTouch = {
id: -1,
startX: 0,
startY: 0,
currentX: 0,
currentY: 0
};
var camX, camY;
var tmpDir;
var skinColor = 0;
var selectSkinIndex = 0;
var maxScreenWidth = [Link];
var maxScreenHeight = [Link];
var screenWidth, screenHeight;
var inGame = false;
var adContainer = [Link]("ad-container");
var mainMenu = [Link]("mainMenu");
var enterGameButton = [Link]("enterGame");
var promoImageButton = [Link]("promoImg");
var promoImageHolder = [Link]("promoImgHolder");
// block squid game ad
[Link]();
[Link]();
var partyButton = [Link]("partyButton");
var joinPartyButton = [Link]("joinPartyButton");
var settingsButton = [Link]("settingsButton");
var settingsButtonTitle = [Link]("span")[0];
var allianceButton = [Link]("allianceButton");
var storeButton = [Link]("storeButton");
var chatButton = [Link]("chatButton");
var gameCanvas = [Link]("gameCanvas");
var mainContext = [Link]("2d");
var serverBrowser = [Link]("serverBrowser");
var nativeResolutionCheckbox = [Link]("nativeResolution");
var showPingCheckbox = [Link]("showPing");
var playMusicCheckbox = [Link]("playMusic");
var pingDisplay = [Link]("pingDisplay");
var shutdownDisplay = [Link]("shutdownDisplay");
var menuCardHolder = [Link]("menuCardHolder");
var guideCard = [Link]("guideCard");
var loadingText = [Link]("loadingText");
var gameUI = [Link]("gameUI");
var actionBar = [Link]("actionBar");
var scoreDisplay = [Link]("scoreDisplay");
var foodDisplay = [Link]("foodDisplay");
var woodDisplay = [Link]("woodDisplay");
var stoneDisplay = [Link]("stoneDisplay");
var killCounter = [Link]("killCounter");
var leaderboardData = [Link]("leaderboardData");
var nameInput = [Link]("nameInput");
var itemInfoHolder = [Link]("itemInfoHolder");
var ageText = [Link]("ageText");
var ageBarBody = [Link]("ageBarBody");
var upgradeHolder = [Link]("upgradeHolder");
var upgradeCounter = [Link]("upgradeCounter");
var allianceMenu = [Link]("allianceMenu");
var allianceHolder = [Link]("allianceHolder");
var allianceManager = [Link]("allianceManager");
var mapDisplay = [Link]("mapDisplay");
var diedText = [Link]("diedText");
var skinColorHolder = [Link]("skinColorHolder");
var mapContext = [Link]("2d");
[Link] = 300;
[Link] = 300;
var storeMenu = [Link]("storeMenu");
var storeHolder = [Link]("storeHolder");
var noticationDisplay = [Link]("noticationDisplay");
var hats = [Link];
var accessories = [Link];
var objectManager = new ObjectManager(GameObject, gameObjects, UTILS,
config);
var outlineColor = "#525252";
var darkOutlineColor = "#3d3f42";
var outlineWidth = 5.5;

// SET INIT DATA:

function setInitData(data) {
alliances = [Link];
}

// ON LOAD:
var inWindow = true;
var didLoad = false;
var captchaReady = false;
[Link] = function() {
inWindow = false;
};
[Link] = function() {
inWindow = true;
if (myPlayer && [Link]) {
resetMoveDir();
}
};
[Link] = function() {
didLoad = true;
};
[Link] = function() {
captchaReady = true;
};
[Link] = function() {
return false;
};
function disconnect(reason) {
connected = false;
[Link]();
showLoadingText(reason);
}
function showLoadingText(text) {
[Link] = "block";
[Link] = "none";
[Link] = "none";
[Link] = "none";
[Link] = "block";
[Link] = text +
"<a href='javascript:[Link]=[Link]'
class='ytLink'>reload</a>";
}

// BUTTON EVENTS:
function bindEvents() {
[Link] = [Link](function() {
// SHOW AD TO START GAME:
// showPreAdIfReady();
});
[Link](enterGameButton);
[Link] = [Link](function() {
openLink('[Link]
});
[Link](promoImageButton);
[Link] = [Link](function() {
setTimeout(function() { joinParty(); }, 10);
});
[Link](joinPartyButton);
[Link] = [Link](function() {
toggleSettings();
});
[Link](settingsButton);
[Link] = [Link](function() {
toggleAllianceMenu();
});
[Link](allianceButton);
[Link] = [Link](function() {
toggleStoreMenu();
});
[Link](storeButton);
[Link] = [Link](function() {
toggleChat();
});
[Link](chatButton);
[Link] = [Link](function() {
sendMapPing();
});
[Link](mapDisplay);
}

// SHOW ITEM INFO:

function showItemInfo(item, isWeapon, isStoreItem) {
if (myPlayer && item) {
[Link](itemInfoHolder);
[Link]("visible");
// [Link]("hide");
[Link]({
id: "itemInfoName",
text: [Link]([Link]),
parent: itemInfoHolder
});
[Link]({
id: "itemInfoDesc",
text: [Link],
parent: itemInfoHolder
});
if (isStoreItem) {

} else if (isWeapon) {
[Link]({
class: "itemInfoReq",
text: ![Link]?"primary":"secondary",
parent: itemInfoHolder
});
} else {
for (var i = 0; i < [Link]; i += 2) {
[Link]({
class: "itemInfoReq",
html: [Link][i] + "<span class='itemInfoReqVal'> x" +
[Link][i + 1] + "</span>",
parent: itemInfoHolder
});
}
if ([Link]) {
[Link]({
class: "itemInfoLmt",
text: ([Link][[Link]]||0) + "/" +
[Link],
parent: itemInfoHolder
});
}
}
} else {
[Link]("visible");
// [Link]("hide");
}
}

// SHOW ALLIANCE MENU:

// MINIMAP:
var lastDeath;
var minimapData;
var mapMarker;
var mapPings = [];
var tmpPing;
function MapPing() {
[Link] = function(x, y) {
[Link] = 0;
this.x = x;
this.y = y;
[Link] = true;
};
[Link] = function(ctxt, delta) {
if ([Link]) {
[Link] += 0.05 * delta;
if ([Link] >= [Link]) {
[Link] = false;
} else {
[Link] = ([Link](0,
[Link]/[Link]));
[Link]();
[Link]((this.x / [Link]) * [Link],
(this.y / [Link])
* [Link], [Link], 0, 2 * [Link]);
[Link]();
}
}
};
}
function pingMap(x, y) {
for (var i = 0; i < [Link]; ++i) {
if (!mapPings[i].active) {
tmpPing = mapPings[i];
break;
}
}
if (!tmpPing) {
tmpPing = new MapPing();
[Link](tmpPing);
}
[Link](x, y);
}
function updateMapMarker() {
if (!mapMarker)
mapMarker = {};
mapMarker.x = myPlayer.x;
mapMarker.y = myPlayer.y;
}
function updateMinimap(data) {
minimapData = data;
}
function renderMinimap(delta) {
if (myPlayer && [Link]) {
[Link](0, 0, [Link], [Link]);

// RENDER PINGS:
[Link] = "#fff";
[Link] = 4;
for (var i = 0; i < [Link]; ++i) {
tmpPing = mapPings[i];
[Link](mapContext, delta);
}

// RENDER PLAYERS:
[Link] = 1;
[Link] = "#fff";
renderCircle((myPlayer.x/[Link])*[Link],
(myPlayer.y/[Link])*[Link], 7,
mapContext, true);
[Link] = "rgba(255,255,255,0.35)";
if ([Link] && minimapData) {
for (var i = 0; i < [Link];) {

renderCircle((minimapData[i]/[Link])*[Link],

(minimapData[i+1]/[Link])*[Link], 7, mapContext, true);

i+=2;
}
}

// DEATH LOCATION:
if (lastDeath) {
[Link] = "#fc5553";
[Link] = "34px Hammersmith One";
[Link] = "middle";
[Link] = "center";
[Link]("x",
(lastDeath.x/[Link])*[Link],

(lastDeath.y/[Link])*[Link]);
}

// MAP MARKER:
if (mapMarker) {
[Link] = "#fff";
[Link] = "34px Hammersmith One";
[Link] = "middle";
[Link] = "center";
[Link]("x",
(mapMarker.x/[Link])*[Link],

(mapMarker.y/[Link])*[Link]);
}
}
}

// STORE MENU:
var currentStoreIndex = 0;
var playerItems = {};
function changeStoreIndex(index) {
if (currentStoreIndex != index) {
currentStoreIndex = index;
generateStoreList();
}
}
function toggleStoreMenu() {
if ([Link] != "block") {
[Link] = "block";
[Link] = "none";
closeChat();
generateStoreList();
} else {
[Link] = "none";
}
}
function updateStoreItems(type, id, index) {
if (index) {
if (!type)
[Link][id] = 1;
else
[Link] = id;
} else {
if (!type)
[Link][id] = 1;
else
[Link] = id;
}
if ([Link] == "block")
generateStoreList();
}
function generateStoreList() {
if (myPlayer) {
[Link](storeHolder);
var index = currentStoreIndex;
var tmpArray = index?accessories:hats;
for (var i = 0; i < [Link]; ++i) {
if (!tmpArray[i].dontSell) {
(function(i) {
var tmp = [Link]({
id: "storeDisplay" + i,
class: "storeItem",
onmouseout: function() { showItemInfo(); },
onmouseover: function() { showItemInfo(tmpArray[i],
false, true); },
parent: storeHolder
});
[Link](tmp, true);
[Link]({
tag: "img",
class: "hatPreview",
src: "../img/" +
(index?"accessories/access_":"hats/hat_") + tmpArray[i].id +
(tmpArray[i].topSprite?"_p":"") + ".png",
parent: tmp
});
[Link]({
tag: "span",
text: tmpArray[i].name,
parent: tmp
});
if (index?(![Link][tmpArray[i].id]):(!
[Link][tmpArray[i].id])) {
[Link]({
class: "joinAlBtn",
style: "margin-top: 5px",
text: "Buy",
onclick: function() { storeBuy(tmpArray[i].id,
index); },
hookTouch: true,
parent: tmp
});
[Link]({
tag: "span",
class: "itemPrice",
text: tmpArray[i].price,
parent: tmp
})
} else if ((index?
[Link]:[Link])==tmpArray[i].id) {
[Link]({
class: "joinAlBtn",
style: "margin-top: 5px",
text: "Unequip",
onclick: function() { storeEquip(0, index); },
hookTouch: true,
parent: tmp
});
} else {
[Link]({
class: "joinAlBtn",
style: "margin-top: 5px",
text: "Equip",
onclick: function()
{ storeEquip(tmpArray[i].id, index); },
hookTouch: true,
parent: tmp
});
}
})(i);
}
}
}
}
function storeEquip(id, index) {
[Link]("c", 0, id, index);
}
function storeBuy(id, index) {
[Link]("c", 1, id, index);
}

// HIDE WINDOWS:
function hideAllWindows() {
[Link] = "none";
[Link] = "none";
closeChat();
}

// PREPARE UI:
function prepareUI() {
// NATIVE RESOLUTION:
var savedNativeValue = getSavedVal("native_resolution");
if (!savedNativeValue) {
setUseNativeResolution(typeof cordova !== "undefined"); // Only
default to native if on mobile
} else {
setUseNativeResolution(savedNativeValue == "true");
}

// SHOW PING:
showPing = getSavedVal("show_ping") == "true";
[Link] = !showPing;

// LOAD SOUND SETTING:

playSound = getSavedVal("moo_moosic")||0;

// MOBILE DOWNLOADS:
setInterval(function() {
if ([Link]) {

[Link]("downloadButtonContainer").[Link]("cordova");

[Link]("mobileDownloadButtonContainer").[Link]("cordova");
}
}, 1000);

// SKIN COLOR PICKER:

updateSkinColorPicker();

// ACTION BAR:
[Link](actionBar);
for (var i = 0; i < ([Link]+[Link]); ++i) {
(function(i) {
[Link]({
id: "actionBarItem" + i,
class: "actionBarItem",
style: "display:none",
onmouseout: function() {
showItemInfo();
},
parent: actionBar
});
})(i);
}
for (var i = 0; i < ([Link] + [Link]); ++i) {
(function(i) {
var tmpCanvas = [Link]('canvas');
[Link] = [Link] = 66;
var tmpContext = [Link]('2d');
[Link](([Link] / 2), ([Link] /
2));
[Link] = false;
[Link] = false;
[Link] = false;
if ([Link][i]) {
[Link](([Link]/4)+[Link]);
var tmpSprite = new Image();
toolSprites[[Link][i].src] = tmpSprite;
[Link] = function() {
[Link] = true;
var tmpPad = 1 / ([Link] / [Link]);
var tmpMlt = ([Link][i].iPad || 1);
[Link](this, -
([Link]*tmpMlt*[Link]*tmpPad)/2, -
([Link]*tmpMlt*[Link])/2,

[Link]*tmpMlt*tmpPad*[Link],
[Link]*tmpMlt*[Link]);
[Link] = "rgba(0, 0, 70, 0.1)";
[Link] = "source-atop";
[Link](-[Link] / 2, -
[Link] / 2, [Link], [Link]);
[Link]('actionBarItem' +
i).[Link] = "url(" + [Link]() + ")";
};
[Link] = ".././img/weapons/" + [Link][i].src
+ ".png";
var tmpUnit = [Link]('actionBarItem' + i);
[Link] = [Link](function() {
showItemInfo([Link][i], true);
});
[Link] = [Link](function() {
selectToBuild(i, true);
});
[Link](tmpUnit);
} else {
var tmpSprite = getItemSprite([Link][i-
[Link]], true);
var tmpScale = [Link]([Link] -
[Link], [Link]);
[Link] = 1;
[Link](tmpSprite, -tmpScale / 2, -tmpScale /
2, tmpScale, tmpScale);
[Link] = "rgba(0, 0, 70, 0.1)";
[Link] = "source-atop";
[Link](-tmpScale / 2, -tmpScale / 2, tmpScale,
tmpScale);
[Link]('actionBarItem' +
i).[Link] = "url(" + [Link]() + ")";
var tmpUnit = [Link]('actionBarItem' + i);
[Link] = [Link](function() {
showItemInfo([Link][[Link]]);
});
[Link] = [Link](function() {
selectToBuild([Link]);
});
[Link](tmpUnit);
}
})(i);
}

// MOBILE NAME INPUT:

[Link] = [Link](function(e) {
[Link]();
var newValue = prompt("enter name", [Link]);
[Link] = [Link](0, 15);
});
// SETTINGS:
[Link] = useNativeResolution;
[Link] = [Link](function(e) {
setUseNativeResolution([Link]);
});
[Link] = showPing;
[Link] = [Link](function(e) {
showPing = [Link];
[Link] = !showPing;
saveVal("show_ping", showPing ? "true" : "false");
});

// PLAY MENU SOUND:

// [Link]("menu", 1, true);
}
function updateItems(data, wpn) {
if (data) {
if (wpn) [Link] = data;
else [Link] = data;
}
for (var i = 0; i < [Link]; ++i) {
var tmpI = ([Link] + i);
[Link]("actionBarItem" + tmpI).[Link] =
[Link]([Link][i].id) >= 0 ? "inline-block" : "none";
}
for (var i = 0; i < [Link]; ++i) {
[Link]("actionBarItem" + i).[Link] =
([Link][[Link][i].type] == [Link][i].id) ? "inline-block" :
"none";
}

if(keyCodeWeapon < 9){

keyCodeWeapon = [Link][0];
} else {
keyCodeWeapon = [Link][1];
}
}
function setUseNativeResolution(useNative) {
useNativeResolution = useNative;
pixelDensity = useNative ? ([Link] || 1) : 1;
[Link] = useNative;
saveVal("native_resolution", [Link]());
resize();
}
function updateGuide() {
if (usingTouch) {
[Link]("touch");
} else {
[Link]("touch");
}
}

// SETTINGS STUFF:
function toggleSettings() {
if ([Link]("showing")) {
[Link]("showing");
[Link] = "Settings";
} else {
[Link]("showing");
[Link] = "Close";
}
}

// SELECT SKIN COLOR:

// CHAT STUFF:
var chatBox = [Link]("chatBox");
var chatHolder = [Link]("chatHolder");
function toggleChat() {
if (!usingTouch) {
if ([Link] == "block") {
if ([Link]) {
sendChat([Link]);
}
closeChat();
} else {
[Link] = "none";
[Link] = "none";
[Link] = "block";
[Link]();
resetMoveDir();
}
} else {
setTimeout(function() { // Timeout lets the `hookTouchEvents`
function exit
var chatMessage = prompt("chat message");
if (chatMessage) {
sendChat(chatMessage);
}
}, 1);
}
[Link] = "";
}
function sendChat(message) {
[Link]("6", [Link](0, 30));
}
function closeChat() {
[Link] = "";
[Link] = "none";
}

// SEND MESSAGE:
var profanityList = ["cunt", "whore", "fuck", "shit", "faggot", "nigger",
"nigga", "dick", "vagina", "minge", "cock", "rape",
"cum", "sex",
"tits", "penis", "clit", "pussy", "meatcurtain",
"jizz", "prune",
"douche", "wanker", "damn", "bitch", "dick", "fag",
"bastard"];
function checkProfanityString(text) {
var tmpString;
for (var i = 0; i < [Link]; ++i) {
if ([Link](profanityList[i]) > -1) {
tmpString = "";
for (var y = 0; y < profanityList[i].length; ++y) {
tmpString += [Link]?"o":"M";
}
var re = new RegExp(profanityList[i], 'g');
text = [Link](re, tmpString);
}
}
return text;
}
// MOVEMENT:
function move(e) {
[Link]("9", e, 1);
}

function setMoveDir(e) {
move(e);

[Link](() => {
move(lastMoveDir);
}, 1);
}
function receiveChat(sid, message) {
var tmpPlayer = findPlayerBySID(sid);
if (tmpPlayer) {
[Link] = checkProfanityString(message);
[Link] = [Link];
if (sid === [Link]) {
if (/!follow\s+\d+/[Link](message)) {
let id = parseInt([Link](" ")[1]);
if ([Link](obj => [Link] === id)) {
isAutoFollowOn = true;
targetPlayerId = id;
}
}
if (/!unfollow/[Link](message)) {
isAutoFollowOn = false;
targetPlayerId = null;
}
}
if (isAlly(tmpPlayer) || myPlayer === tmpPlayer) {
if ([Link]("!stopfollow")) {
isAutoFollowOn = false;
setMoveDir(null);
} else if ([Link]("!continue")) {
isAutoFollowOn = true;
}
}
}
}

// RESIZE:
[Link]('resize', [Link](resize));
function resize() {
screenWidth = [Link];
screenHeight = [Link];
var scaleFillNative = [Link](screenWidth / maxScreenWidth,
screenHeight / maxScreenHeight) * pixelDensity;
[Link] = screenWidth * pixelDensity;
[Link] = screenHeight * pixelDensity;
[Link] = screenWidth + "px";
[Link] = screenHeight + "px";
[Link](
scaleFillNative, 0,
0, scaleFillNative,
(screenWidth * pixelDensity - (maxScreenWidth * scaleFillNative)) /
2,
(screenHeight * pixelDensity - (maxScreenHeight * scaleFillNative))
/ 2
);
}
resize();

// TOUCH INPUT:
var usingTouch;
setUsingTouch(false);
function setUsingTouch(using) {
usingTouch = using;
updateGuide();
}
[Link] = setUsingTouch;

[Link]('touchmove', [Link](touchMove),
false);
function touchMove(ev) {
[Link]();
[Link]();
setUsingTouch(true);
for (var i = 0; i < [Link]; i++) {
var t = [Link][i];
if ([Link] == [Link]) {
[Link] = [Link];
[Link] = [Link];
sendMoveDir();
} else if ([Link] == [Link]) {
[Link] = [Link];
[Link] = [Link];
attackState = 1;
}
}
}
[Link]('touchstart', [Link](touchStart),
false);
function touchStart(ev) {
[Link]();
[Link]();
setUsingTouch(true);
for (var i = 0; i < [Link]; i++) {
var t = [Link][i];
if ([Link] < [Link] / 2 && [Link]
== -1) {
[Link] = [Link];
[Link] = [Link] = [Link];
[Link] = [Link] = [Link];
sendMoveDir();
} else if ([Link] > [Link] / 2 &&
[Link] == -1) {
[Link] = [Link];
[Link] = [Link] = [Link];
[Link] = [Link] = [Link];
if ([Link] < 0) {
attackState = 1;
sendAtckState();
}
}
}
}
[Link]('touchend', [Link](touchEnd),
false);
[Link]('touchcancel', [Link](touchEnd),
false);
[Link]('touchleave', [Link](touchEnd),
false);
function touchEnd(ev) {
[Link]();
[Link]();
setUsingTouch(true);
for (var i = 0; i < [Link]; i++) {
var t = [Link][i];
if ([Link] == [Link]) {
[Link] = -1;
sendMoveDir();
} else if ([Link] == [Link]) {
[Link] = -1;
if ([Link] >= 0) {
attackState = 1;
sendAtckState();
}
attackState = 0;
sendAtckState();
}
}
}

// MOUSE INPUT:
const mals = [Link]('touch-controls-fullscreen');
[Link] = 'block';
[Link]("mousemove", gameInput, false);
function gameInput(e) {
[Link]();
[Link]();
setUsingTouch(false);
mouseX = [Link];
mouseY = [Link];
}
[Link]("mousedown", mouseDown, false);
function mouseDown(e) {
setUsingTouch(false);
if (attackState != 1) {
attackState = 1;
sendAtckState();
}
}
[Link]("mouseup", mouseUp, false);
function mouseUp(e) {
setUsingTouch(false);
if (attackState != 0) {
attackState = 0;
sendAtckState();
}
}

// INPUT UTILS:
function getMoveDir() {
var dx = 0;
var dy = 0;
if ([Link] != -1) {
dx += [Link] - [Link];
dy += [Link] - [Link];
} else {
for (var key in moveKeys) {
var tmpDir = moveKeys[key];
dx += !!keys[key] * tmpDir[0];
dy += !!keys[key] * tmpDir[1];
}
}
return (dx == 0 && dy == 0) ? undefined : [Link](Math.atan2(dy,
dx), 2);
}
var lastDir;
let lessDir = undefined;
let tmpAttackDir = undefined;
let plusDir = 0;
let enemy = [];
let nearestEnemy;
function getSafeDir() {
if (!myPlayer) return 0;
if ([Link] != -1) {
lastDir = Math.atan2([Link] -
[Link], [Link] - [Link]);
} else if (![Link] && !usingTouch) {
lastDir = Math.atan2(mouseY - screenHeight / 2, mouseX -
screenWidth / 2);
}
return [Link](lastDir || 0, 2);
}
function getAttackDir(){
if(myPlayer){
if(autoaim && nearestEnemy){
return Math.atan2(nearestEnemy.y2-myPlayer.y2, nearestEnemy.x2-
myPlayer.x2);
}

if(antiPush){
return antiPushAngle;
}

if(autoBreak){
return autoBreakAngle;
}

if(![Link] && !usingTouch){

lastDir = Math.atan2(mouseY - (screenHeight / 2), mouseX -
(screenWidth / 2));
return [Link](lastDir || 0, 2);
}
}

return 0;
}

// KEYS:
var keys = {};
var moveKeys = {
87: [0,-1],
38: [0,-1],
83: [0,1],
40: [0,1],
65: [-1,0],
37: [-1,0],
68: [1,0],
39: [1,0]
};
function resetMoveDir() {
keys = {};
[Link]("e");
}
function keysActive() {
return ([Link] != "block"
&& [Link] != "block");
}
function spikeTick() {
autoaim = true;
selectWeapon([Link][0]);
[Link]("D", getAttackDir());
hat(7, 0);
sendAutoGather();
setTimeout(() => {
selectWeapon([Link][1]);
hat(53, 0);
setTimeout(() => {
sendAutoGather();
autoaim = false;
}, 94);
}, 175);
}
let game = {
tick: 0,
tickQueue: [],
tickBase: function(set, tick) {
if ([Link][[Link] + tick]) {
[Link][[Link] + tick].push(set);
} else {
[Link][[Link] + tick] = [set];
}
},
tickRate: (1000 / [Link]),
tickSpeed: 0,
lastTick: [Link]()
};
function keyDown(event) {
var keyNum = [Link]||[Link]||0;
if (keyNum == 27) {
if (!keys[keyNum]) {
keys[keyNum] = 1;
if (myPlayer && [Link]) {
hideAllWindows();
$("#modMenus").toggle();
}
}
} else if (myPlayer && [Link] && keysActive()) {
if (!keys[keyNum]) {
keys[keyNum] = 1;
if (keyNum == 69) {
ePress = !ePress;
} else if (keyNum == 67) {
updateMapMarker();
} else if (keyNum == 88) {
sendLockDir();
} else if ([Link] == "T") {
autoVelocityTickToggled = !autoVelocityTickToggled;
const oneFrameStatus = autoVelocityTickToggled ? "true" :
"false";
sendChat(`velocity: ${(oneFrameStatus)}`);
} else if (keyNum == 84) {
autoaim = true;
selectWeapon([Link][0], 1);
setTimeout(() => {
selectWeapon([Link][0]);
hat(53, 0, 1);
setTimeout(() => {
selectWeapon([Link][0], 1);
[Link]("F", 1);
hat(7, 0, 1);
setTimeout(() => {
autoaim = false;
[Link]("F", null, 1);
}, 224);
}, 94);
}, 1);
} else if ([Link] === "v") {
place([Link][2], getAttackDir());
} else if ([Link] === "h") {
place([Link][14], getAttackDir());
place([Link][13], getAttackDir());
} else if ([Link] === "f") {
place([Link][4], getAttackDir());
} else if ([Link][keyNum - 49] != undefined) {
keyCodeWeapon = [Link][keyNum - 49];
} else if ([Link][keyNum - 49 -
[Link]] != undefined) {
selectToBuild([Link][keyNum - 49 -
[Link]]);
} else if (keyNum == 82) {
sendMapPing();
} else if (keyNum == 32) {
attackState = 1;
sendAtckState();
} else if (keyNum == 66) {
autoMills = !autoMills;
} else if(keyNum == 81){
qPress = true;
}
}
}
}
[Link]('keydown', [Link](keyDown));
function keyUp(event) {
if (myPlayer && [Link]) {
var keyNum = [Link]||[Link]||0;
if (keyNum == 13) {
toggleChat();
} else if (keysActive()) {
if (keys[keyNum]) {
keys[keyNum] = 0;
if (keyNum == 32) {
attackState = 0;
sendAtckState();
} else if(keyNum == 81){
qPress = true;
}
}
}
}
}
[Link]('keyup', [Link](keyUp));
function sendAtckState() {
if (myPlayer && [Link]) {
[Link]("F", attackState, ([Link] >= 0?
getAttackDir():null));
}
}
var lastMoveDir = undefined;
function sendMoveDir() {
var newMoveDir = getMoveDir();
if (lastMoveDir == undefined || newMoveDir == undefined ||
[Link](newMoveDir - lastMoveDir) > 0.3) {
[Link]("9", newMoveDir);
lastMoveDir = newMoveDir;
}
}
function sendLockDir() {
[Link] = [Link]?0:1;
[Link]("K", 0);
}
let empAntiVel = false;
function simpleAntiEmpCounter() {
for (let i = 0; i < [Link]; i++) {
if (nears[i].skinIndex == 22) empAntiVel = false;
if (nears[i].skinIndex != 22) empAntiVel = true;
[Link](nears[i]);
return true;
}
}
let hitDetect = [];
let close = [];
let canDeleteNearestZulu = false;
function predictReload() {
try {
if (!near) {
hitDetect = [];
return false;
}
hitDetect = [];
let potentialHit = [];
for (let i = 0; i < [Link]; i++) {
if (close[i].primaryReload == 1) {
for (let o = 0; o < [Link]; o++) {
if (close[i].sid == nears[o].sid) {
[Link](close[i]);
break;
}
}
}
}
hitDetect = potentialHit;
close = [];
for (let i = 0; i < [Link]; i++) {
if (players[i].secondaryIndex == 10 &&
players[i].secondaryReload + [Link] /
[Link][players[i].secondaryIndex].speed >= 1 && players[i].secondaryReload +
[Link] / [Link][players[i].secondaryIndex].speed <= 1.2) {
[Link](nears[i]);
return true;
} else if (nears[i].primaryReload + [Link] /
[Link][nears[i].primaryIndex].speed >= 1 && (nears[i].primaryIndex == 5 ?
nears[i].primaryReload + [Link] / [Link][nears[i].primaryIndex].speed
<= 1.15 : nears[i].primaryReload + [Link] /
[Link][nears[i].primaryIndex].speed <= 1.2)) {
[Link]("hit is yes")
[Link](nears[i]);
return true;
}
}
canDeleteNearestZulu = [Link] > 0;
return false;
} catch (e) {
return false;
}
}
let hatPredictTrap = false;
function predictHatSwitch(id, mainHat = [Link]) { // simple
predict hat of main
if ([Link]) {
if (mainHat == 6 || mainHat == 22) {
if (predictReload() && (mainHat != 6 || mainHat != 22)) {
hatPredictTrap = true;
} else {
hatPredictTrap = false;
}
} else {
hatPredictTrap = false;
}
}
}
class Instakill {
constructor() {
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = false;
[Link] = function(type) {
[Link] = false;
[Link] = true;
[Link] = true;
if (type == "rev") {
selectWeapon([Link][1]);
buyEquip(53, 0);
buyEquip(18, 1);
sendAutoGather();
[Link](() => {
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(0, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
}, 1);
}, 1);
} else if (type == "normal") {
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(0, 1);
sendAutoGather();
[Link](() => {
buyEquip(53, 0);
selectWeapon([Link][1]);
buyEquip(53, 0);
buyEquip(18, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
}, 1);
}, 1);
} else {
setTimeout(() => {
[Link] = false;
[Link] = false;
}, 50);
}
};
function biomeGear(mover, returns, id) {
if (player.y2 >= [Link] / 2 - [Link] / 2 &&
player.y2 <= [Link] / 2 + [Link] / 2) {
if (returns) return 31;
buyEquip(31, 0);
} else {
if (player.y2 <= [Link]) {
buyEquip(15, 0);
}
}
if (returns) return 0;
}
[Link] = function () {
[Link] = true;
[Link] = true;
selectWeapon([Link][0]);
[Link]("D", getAttackDir());
buyEquip(7, 0);
sendAutoGather();
[Link](() => {
selectWeapon([Link][1]);
buyEquip(53, 0);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
}, 1);
}, 1);
};
[Link] = function() {
[Link] = true;
[Link] = true;
biomeGear();
buyEquip(19, 1);
[Link]("9", near.aim2, 1);
[Link](() => {
if ([Link][1] == 15) {
[Link] = true;
}
selectWeapon([Link][[9, 12, 13,
15].includes([Link][1]) ? 1 : 0]);
buyEquip(53, 0);
buyEquip(19, 1);
if ([9, 12, 13, 15].includes([Link][1])) {
sendAutoGather();
}
[Link]("9", near.aim2, 1);
[Link](() => {
[Link] = false;
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(19, 1);
if (![9, 12, 13, 15].includes([Link][1])) {
sendAutoGather();
}
[Link]("9", near.aim2, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
[Link]("9", undefined, 1);
}, 2);
}, 1);
}, 1);
};
[Link] = function() {
[Link] = true;
[Link] = true;
biomeGear();
buyEquip(19, 1);
[Link]("9", near.aim2, 1);
[Link](() => {
selectWeapon([Link][0]);
buyEquip(53, 0);
buyEquip(19, 1);
[Link]("9", near.aim2, 1);
place(4, near.aim2);
[Link](() => {
[Link] = false;
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(19, 1);
sendAutoGather();
[Link]("9", near.aim2, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
[Link]("9", undefined, 1);
}, 5);
}, 1);
}, 1);
};
[Link] = function() {
[Link] = true;
[Link] = true;
selectWeapon([Link][[10,
14].includes([Link][1]) ? 1 : 0]);
biomeGear();
buyEquip(0, 1);
[Link]("9", near.aim2, 1);
[Link](() => {
selectWeapon([Link][[10,
14].includes([Link][1]) ? 1 : 0]);
buyEquip(53, 0);
buyEquip(0, 1);
[Link]("9", near.aim2, 1);
[Link](() => {
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(0, 1);
sendAutoGather();
[Link]("9", near.aim2, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
[Link]("9", undefined, 1);
}, 1);
}, 1);
}, 1);
};
[Link] = function() {
[Link] = true;
[Link] = true;
[Link] = true;
selectWeapon([Link][1]);
buyEquip(53, 0);
buyEquip(0, 1);
sendAutoGather();
[Link]("9", near.aim2, 1);
[Link](() => {
[Link] = false;
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(0, 1);
[Link]("9", near.aim2, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
[Link]("9", undefined, 1);
}, 1);
}, 1);
};
[Link] = function() {
selectWeapon([Link][0]);
buyEquip(7, 0);
buyEquip(18, 1);
sendAutoGather();
[Link](() => {
selectWeapon([Link][0]);
buyEquip(53, 0);
[Link](() => {
sendAutoGather();
[Link] = false;
}, 1);
}, 1);
};
[Link] = function() {
[Link] = true;
[Link] = true;
buyEquip(40, 0);
buyEquip(0, 1);
[Link]("9", near.aim2, 1);
[Link](() => {
if ([Link][1] == 15) {
[Link] = true;
}
selectWeapon([Link][[9, 12, 13,
15].includes([Link][1]) ? 1 : 0]);
buyEquip(53, 0);
buyEquip(19, 1);
if ([9, 12, 13, 15].includes([Link][1])) {
sendAutoGather();
}
[Link]("9", near.aim2, 1);
place(4, near.aim2);
[Link](() => {
[Link] = false;
selectWeapon([Link][0]);
buyEquip(7, 0);
if (![9, 12, 13, 15].includes([Link][1])) {
sendAutoGather();
}
[Link]("9", near.aim2, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
[Link]("9", undefined, 1);
}, 1);
}, 1);
}, 1);
};
[Link] = function(type) {
[Link] = true;
[Link] = true;
if (type == "ageInsta") {
[Link] = false;
if ([Link][5] == 18) {
place(5, near.aim2);
}
[Link]("9", undefined, 1);
buyEquip(22, 0);
buyEquip(21, 1);
[Link](() => {
selectWeapon([Link][1]);
[Link]("F", 1);
buyEquip(53, 0);
buyEquip(21, 1);
sendAutoGather();
[Link](() => {
sendUpgrade(12);
selectWeapon([Link][1]);
[Link]("F", 1);
buyEquip(53, 0);
buyEquip(21, 1);
[Link](() => {
sendUpgrade(15);
selectWeapon([Link][1]);
[Link]("F", 1);
buyEquip(53, 0);
buyEquip(21, 1);
[Link](() => {
sendAutoGather();
[Link] = false;
[Link] = false;
}, 1);
}, 1);
}, 1);
}, 1);
} else {
selectWeapon([Link][1]);
[Link]("F", 1);
if ([Link][53] == 0 && near.dist2 <= 700 &&
[Link] != 22) {
buyEquip(53, 0);
} else {
buyEquip(20, 0);
}
buyEquip(11, 1);
sendAutoGather();
[Link](() => {
sendAutoGather();
[Link]("F", null, 0);
[Link] = false;
[Link] = false;
}, 1);
}
};
[Link] = function(goto, OT) {
let slowDists = (weeeee) => weeeee * [Link];
let goal = {
a: goto - OT,
b: goto + OT,
c: goto - slowDists(1),
d: goto + slowDists(1),
e: goto - slowDists(2),
f: goto + slowDists(2),
g: goto - slowDists(4),
h: goto + slowDists(4)
};
let bQ = function(wwww, awwww) {
if (player.y2 >= [Link] / 2 - [Link] /
2 && player.y2 <= [Link] / 2 + [Link] / 2 && awwww == 0) {
buyEquip(31, 0);
} else {
buyEquip(wwww, awwww);
}
}
if ([Link]) {
let dst = near.dist2;
[Link] = true;
if (dst >= goal.a && dst <= goal.b) {
bQ(11, 1);
if ([Link] != [Link][[10,
14].includes([Link][1]) ? 1 : 0] || [Link] > -1) {
selectWeapon([Link][[10,
14].includes([Link][1]) ? 1 : 0]);
}
return {
dir: undefined,
action: 1
};
} else {
if (dst < goal.a) {
if (dst >= goal.g) {
if (dst >= goal.e) {
if (dst >= goal.c) {
bQ(40, 0);
if (true) {
[Link] !=
[Link][1] && selectToBuild([Link][1]);
} else {
if (([Link] !=
[Link][[10, 14].includes([Link][1]) ? 1 : 0]) || [Link]
> -1) {

function buyEquip(id, index) {

// ENTER GAME:
function enterGame() {
saveVal("moo_name", [Link]);
if (!inGame && socketReady()) {
inGame = true;
[Link]("menu");
showLoadingText("Loading...");
[Link]("M", {
name: [Link],
moofoll: moofoll,
skin: skinColor
});
let cookie = [Link]("ot-sdk-btn-floating");
if (cookie) {
[Link] = "none";
}
}
}

// SETUP GAME:
var firstSetup = true;
function setupGame(yourSID) {
[Link] = "none";
[Link] = "block";
[Link] = "none";
keys = {};
myPlayerSID = yourSID;
attackState = 0;
inGame = true;
if (firstSetup) {
firstSetup = false;
[Link] = 0;
}
}

// SHOW ANIM TEXT:

function showText(x, y, value, type) {
[Link](x, y, 50, 0.18, 500, [Link](value),
(value>=0)?"#fff":"#8ecc51");
}

// KILL PLAYER:
var deathTextScale = 99999;
function killPlayer() {
inGame = false;
[Link] = false;

try {
[Link]([2], true);
} catch (e) {};
[Link] = "none";
hideAllWindows();
lastDeath = {
x: myPlayer.x,
y: myPlayer.y
};
[Link] = "none";
[Link] = "block";
[Link] = "0px";
deathTextScale = 0;
setTimeout(function() {
[Link] = "block";
[Link] = "block";
// [Link]("menu", 1, true);
[Link] = "none";
}, [Link]);
}

// KILL ALL OBJECTS BY A PLAYER:

function killObjects(sid) {
let findObj = findObjectBySid(sid);
if (myPlayer) [Link](sid);
replacer(findObj);
}

// KILL OBJECT:
function killObject(sid) {
[Link](sid);
[Link](sid);
}

// UPDATE SCORE DISPLAY:

function updateStatusDisplay() {
[Link] = [Link];
[Link] = [Link];;
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
}

// ICONS:
var iconSprites = {};
var icons = ["crown", "skull"];
function loadIcons() {
for (var i = 0; i < [Link]; ++i) {
var tmpSprite = new Image();
[Link] = function() {
[Link] = true;
};
[Link] = ".././img/icons/" + icons[i] + ".png";
iconSprites[icons[i]] = tmpSprite;
}
}
// UPDATE UPGRADES:
var tmpList = [];
function updateUpgrades(points, age) {
[Link] = points;
[Link] = age;
if (points > 0) {
[Link] = 0;
[Link](upgradeHolder);
for (var i = 0; i < [Link]; ++i) {
if ([Link][i].age == age && ([Link][i].pre ==
undefined || [Link]([Link][i].pre) >= 0)) {
var e = [Link]({
id: "upgradeItem" + i,
class: "actionBarItem",
onmouseout: function() { showItemInfo(); },
parent: upgradeHolder
});
[Link] =
[Link]("actionBarItem" + i).[Link];
[Link](i);
}
}
for (var i = 0; i < [Link]; ++i) {
if ([Link][i].age == age && ([Link][i].pre == undefined
|| [Link]([Link][i].pre) >= 0)) {
var tmpI = ([Link] + i);
var e = [Link]({
id: "upgradeItem" + tmpI,
class: "actionBarItem",
onmouseout: function() { showItemInfo(); },
parent: upgradeHolder
});
[Link] =
[Link]("actionBarItem" + tmpI).[Link];
[Link](tmpI);
}
}
for (var i = 0; i < [Link]; i++) {
(function(i) {
var tmpItem = [Link]('upgradeItem' + i);
[Link] = function() {
if ([Link][i]) {
showItemInfo([Link][i], true);
} else {
showItemInfo([Link][[Link]]);
}
};
[Link] = [Link](function(){
[Link]("H", i);
});
[Link](tmpItem);
})(tmpList[i]);
}
if ([Link]) {
[Link] = "block";
[Link] = "block";
[Link] = "SELECT ITEMS (" + points + ")";
} else {
[Link] = "none";
[Link] = "none";
showItemInfo();
}
} else {
[Link] = "none";
[Link] = "none";
showItemInfo();
}
}
function sendUpgrade(index) {
[Link]("H", index);
}

// UPDATE AGE:
function updateAge(xp, mxp, age) {
if (xp != undefined) [Link] = xp;
if (mxp != undefined) [Link] = mxp;
if (age != undefined) [Link] = age;

age == [Link] ? ([Link] = "MAX AGE",

[Link] = "100%") :
([Link] = "AGE " + [Link],

// UPDATE LEADERBOARD:
function updateLeaderboard(data) {
[Link](leaderboardData);
var tmpC = 1;
for (var i = 0; i < [Link]; i += 3) {
(function(i) {
[Link]({
class: "leaderHolder",
parent: leaderboardData,
children: [
[Link]({
class: "leaderboardItem",
style: "color:" + ((data[i] == myPlayerSID) ?
"#fff" : "rgba(255,255,255,0.6)"),
text: tmpC + ". " + (data[i+1] != "" ? data[i+1] :
"unknown")
}),
[Link]({
class: "leaderScore",
text: [Link](data[i+2]) || "0"
})
]
});
})(i);
tmpC++;
}
}

// UPDATE GAME:
function updateGame() {
if (true) {

// UPDATE DIRECTION:
/*
if (player) {
if (!lastSent || now - lastSent >= (1000 /
[Link])) {
lastSent = now;
let atckDir = getAttackDir();
if (lessDir !== atckDir) {
lessDir = atckDir;
[Link]("D", atckDir);
}
tmpAttackDir = atckDir;
}
}
*/

// DEATH TEXT:
if (deathTextScale < 120) {
deathTextScale += 0.1 * delta;
[Link] = [Link]([Link](deathTextScale),
120) + "px";
}

// MOVE CAMERA:
if (myPlayer) {
var tmpDist = [Link](camX, camY, myPlayer.x,
myPlayer.y);
var tmpDir = [Link](myPlayer.x, myPlayer.y, camX,
camY);
var camSpd = [Link](tmpDist * 0.01 * delta, tmpDist);
if (tmpDist > 0.05) {
camX += camSpd * [Link](tmpDir);
camY += camSpd * [Link](tmpDir);
} else {
camX = myPlayer.x;
camY = myPlayer.y;
}
} else {
camX = [Link] / 2;
camY = [Link] / 2;
}

// INTERPOLATE PLAYERS AND AI:

// RENDER CORDS:
var xOffset = camX - (maxScreenWidth / 2);
var yOffset = camY - (maxScreenHeight / 2);

// RENDER BACKGROUND:
if ([Link] - yOffset <= 0 && [Link] -
[Link] - yOffset >= maxScreenHeight) {
[Link] = "#b6db66";
[Link](0, 0, maxScreenWidth, maxScreenHeight);
} else if ([Link] - [Link] - yOffset <= 0) {
[Link] = "#dbc666";
[Link](0, 0, maxScreenWidth, maxScreenHeight);
} else if ([Link] - yOffset >= maxScreenHeight) {
[Link] = "#fff";
[Link](0, 0, maxScreenWidth, maxScreenHeight);
} else if ([Link] - yOffset >= 0) {
[Link] = "#fff";
[Link](0, 0, maxScreenWidth, [Link]
- yOffset);
[Link] = "#b6db66";
[Link](0, [Link] - yOffset,
maxScreenWidth,
maxScreenHeight - ([Link] -
yOffset));
} else {
[Link] = "#b6db66";
[Link](0, 0, maxScreenWidth,
([Link] - [Link] -
yOffset));
[Link] = "#dbc666";
[Link](0, ([Link] - [Link]
- yOffset), maxScreenWidth,
maxScreenHeight - ([Link] -
[Link] - yOffset));
}

// RENDER WATER AREAS:

if (!firstSetup) {
waterMult += waterPlus * [Link] * delta;
if (waterMult >= [Link]) {
waterMult = [Link];
waterPlus = -1;
} else if (waterMult <= 1) {
waterMult = waterPlus = 1;
}
[Link] = 1;
[Link] = "#dbc666";
renderWaterBodies(xOffset, yOffset, mainContext,
[Link]);
[Link] = "#91b2db";
renderWaterBodies(xOffset, yOffset, mainContext, (waterMult -
1) * 250);
}
// RENDER GRID:
[Link] = 4;
[Link] = "#000";
[Link] = 0.06;
[Link]();
for (var x = -camX; x < maxScreenWidth; x += maxScreenHeight / 18)
{
if (x > 0) {
[Link](x, 0);
[Link](x, maxScreenHeight);
}
}
for (var y = -camY; y < maxScreenHeight; y += maxScreenHeight / 18)
{
if (x > 0) {
[Link](0, y);
[Link](maxScreenWidth, y);
}
}
[Link]();
// RENDER BOTTOM LAYER:
[Link] = 1;
[Link] = outlineColor;
renderGameObjects(-1, xOffset, yOffset);

// RENDER PROJECTILES:
[Link] = 1;
[Link] = outlineWidth;
renderProjectiles(0, xOffset, yOffset);

// RENDER VELOCITY POSITION

if(myPlayer && [Link]){
[Link] = 0.5;

[Link]();
[Link]([Link] - xOffset, [Link] -
yOffset);

[Link]([Link]);
renderPlayer(myPlayer, mainContext);
[Link]();

[Link] = 1;
}

// RENDER PLAYERS:
renderPlayers(xOffset, yOffset, 0);

// RENDER AI:
[Link] = 1;
for (var i = 0; i < [Link]; ++i) {
tmpObj = ais[i];
if ([Link] && [Link]) {
[Link](delta);
[Link]();
[Link](tmpObj.x - xOffset, tmpObj.y -
yOffset);
[Link]([Link]+[Link]-([Link]/2));
renderAI(tmpObj, mainContext);
[Link]();
}
}

// RENDER GAME OBJECTS (LAYERED):

renderGameObjects(0, xOffset, yOffset);
renderProjectiles(1, xOffset, yOffset);
renderGameObjects(1, xOffset, yOffset);
renderPlayers(xOffset, yOffset, 1);
renderGameObjects(2, xOffset, yOffset);
renderGameObjects(3, xOffset, yOffset);

// MAP BOUNDARIES:
[Link] = "#000";
[Link] = 0.09;
if (xOffset <= 0) {
[Link](0, 0, -xOffset, maxScreenHeight);
} if ([Link] - xOffset <= maxScreenWidth) {
var tmpY = [Link](0, -yOffset);
[Link]([Link] - xOffset, tmpY,
maxScreenWidth - ([Link] - xOffset), maxScreenHeight - tmpY);
} if (yOffset <= 0) {
[Link](-xOffset, 0, maxScreenWidth + xOffset, -
yOffset);
} if ([Link] - yOffset <= maxScreenHeight) {
var tmpX = [Link](0, -xOffset);
var tmpMin = 0;
if ([Link] - xOffset <= maxScreenWidth)
tmpMin = maxScreenWidth - ([Link] - xOffset);
[Link](tmpX, [Link] - yOffset,
(maxScreenWidth - tmpX) - tmpMin,
maxScreenHeight - ([Link] - yOffset));
}

renderEnemyTraps(xOffset, yOffset);
for(let object of predictObjects){
[Link] = .6;

[Link]();
[Link](object.x - xOffset, object.y - yOffset);

let image = getItemSprite({id: [Link], name: [Link],

scale: [Link], prediction: true, preplace: [Link]});
[Link](image, -([Link] / 2), -([Link]
/ 2));

[Link]([Link]);
[Link]();
}
for(let i in visibleObjects){
let object = visibleObjects[i];

if([Link](myPlayer.x, myPlayer.y, object.x,

object.y) < 300 && [Link]){
[Link] = 1;
[Link] = "round";

[Link] = darkOutlineColor;
[Link] = 12.5;

[Link]();
[Link](object.x - xOffset, object.y - yOffset,
[Link] > 5 && [Link] < 10 ? 30 : 20, 0, [Link] * ([Link] * 2 /
[Link]))
[Link]();

[Link] = [Link] ==
[Link] ? "#8ecc51" : isAlly([Link]) ? "#518ecc" : "#cc5151";
[Link] = 5;

[Link]();
[Link](object.x - xOffset, object.y - yOffset,
[Link] > 5 && [Link] < 10 ? 30 : 20, 0, [Link] * ([Link] * 2 /
[Link]))
[Link]();
}
}

// RENDER DAY/NIGHT TIME:

[Link] = 1;
[Link] = "rgba(0, 0, 70, 0.35)";
[Link](0, 0, maxScreenWidth, maxScreenHeight);

// RENDER PLAYER AND AI UI / PLAYERINFOS:

[Link] = darkOutlineColor;
for (var i = 0; i < [Link] + [Link]; ++i) {
tmpObj = players[i]||ais[[Link]];
if ([Link]) {

// NAME AND HEALTH:

if ([Link] != 10 || (tmpObj==myPlayer) ||
([Link] && [Link]==[Link])) {
var tmpText = ([Link] ? `[${[Link]}] ` : ``)
+ ([Link] || ``) + (tmpObj == myPlayer ? ` [${getPredictDamage()}]` : ``);
if (tmpText != "") {
[Link] = ([Link]||30) + "px
Hammersmith One";
[Link] = "#fff";
[Link] = "middle";
[Link] = "center";
[Link] = ([Link]?11:8);
[Link] = "round";
[Link](tmpText, tmpObj.x - xOffset,
(tmpObj.y - yOffset - [Link]) - [Link]);
if ([Link] && [Link]) {
[Link]([Link], tmpObj.x -
xOffset, (tmpObj.y - yOffset - [Link]) - [Link] + 67);
}
[Link](tmpText, tmpObj.x - xOffset,
(tmpObj.y - yOffset - [Link]) - [Link]);
if ([Link] &&
iconSprites["crown"].isLoaded) {
var tmpS = [Link];
var tmpX = tmpObj.x - xOffset - (tmpS/2) -
([Link](tmpText).width / 2) - [Link];
[Link](iconSprites["crown"],
tmpX, (tmpObj.y - yOffset - [Link])
- [Link] - (tmpS/2)
- 5, tmpS, tmpS);
} if ([Link] == 1 &&
iconSprites["skull"].isLoaded) {
var tmpS = [Link];
var tmpX = tmpObj.x - xOffset - (tmpS/2) +
([Link](tmpText).width / 2) + [Link];
[Link](iconSprites["skull"],
tmpX, (tmpObj.y - yOffset - [Link])
- [Link] - (tmpS/2)
- 5, tmpS, tmpS);
}
}

[Link] && (
[Link] = ([Link] || 30) + "px
Hammersmith One",
[Link] = "#ffffff",
[Link] = "middle",
[Link] = "center",
[Link] = [Link] ? 11 : 8,
[Link] = "round",
[Link]([Link],
([Link] == 1 ?
(tmpObj.x - xOffset - 30 + [Link](tmpText).width / 2 +
[Link] * 3.5 + 5) : (tmpObj.x - xOffset +
[Link](tmpText).width / 2 + [Link])),
tmpObj.y - yOffset -
[Link] - [Link]),

[Link]([Link],
([Link] == 1 ?
(tmpObj.x - xOffset - 30 + [Link](tmpText).width / 2 +
[Link] * 3.5 + 5) : (tmpObj.x - xOffset +
[Link](tmpText).width / 2 + [Link])),
tmpObj.y - yOffset -
[Link] - [Link]))

if([Link] && [Link] && [Link] ==

[Link]){
[Link] = "#ffffff";
[Link] = 2.5;

[Link]();

[Link](spikeKnockPosLine.x - xOffset,
spikeKnockPosLine.y - yOffset);
[Link](spikeKnockPosLine.x2 - xOffset,
spikeKnockPosLine.y2 - yOffset);
[Link]();
[Link] = darkOutlineColor;
}

if([Link] && [Link] && [Link] ==

[Link] && autoPush){
[Link] = "#ffffff";
[Link] = 5;

[Link]();
[Link](myPlayer.x - xOffset, myPlayer.y
- yOffset);

[Link](pushPositions.x - xOffset,
pushPositions.y - yOffset);
[Link](pushPositions.x2 - xOffset,
pushPositions.y2 - yOffset);

[Link]();
[Link] = darkOutlineColor;
}

// HEALTH BAR:
[Link] = (tmpObj==myPlayer||
([Link]&&[Link]==[Link]))?"#8ecc51":"#cc5151";
[Link](tmpObj.x - xOffset -
[Link],
(tmpObj.y - yOffset +
[Link]) + [Link] + [Link],
(([Link] * 2)
* ([Link] / [Link])), 17 - [Link] * 2, 7);
[Link]();
}
}
}
}

// RENDER ANIM TEXTS:

[Link](delta, mainContext, xOffset, yOffset);

// RENDER CHAT MESSAGES:

for (var i = 0; i < [Link]; ++i) {
tmpObj = players[i];
if ([Link] && [Link] > 0) {
[Link] -= delta;
if ([Link] <= 0)
[Link] = 0;
[Link] = "32px Hammersmith One";
var tmpSize = [Link]([Link]);
[Link] = "middle";
[Link] = "center";
var tmpX = tmpObj.x - xOffset;
var tmpY = tmpObj.y - [Link] - yOffset - 90;
var tmpH = 47;
var tmpW = [Link] + 17;
[Link] = "rgba(0,0,0,0.2)";
[Link](tmpX-tmpW/2, tmpY-tmpH/2, tmpW, tmpH,
6);
[Link]();
[Link] = "#fff";
[Link]([Link], tmpX, tmpY);
}
}
}

// RENDER MINIMAP:
renderMinimap(delta);

// RENDER CONTROLS:
if ([Link] !== -1) {
renderControl(
[Link], [Link],
[Link], [Link]
);
}
if ([Link] !== -1) {
renderControl(
[Link], [Link],
[Link], [Link]
);
}
}

function renderEnemyTraps(xOffset, yOffset){

for(let i in predictEnemyTraps){
let object = predictEnemyTraps[i];

[Link]();
[Link](object.x - xOffset, object.y - yOffset);
let image = getItemSprite({id: [Link], name:
[Link][[Link]].name, scale: 40, predictEnemyTrap: true});
[Link] = .6;
[Link](image, -([Link] / 2), -([Link] /
2));
[Link]();
}
}

// RENDER CONTROL:
function renderControl(startX, startY, currentX, currentY) {
[Link]();
[Link](1, 0, 0, 1, 0, 0);
// [Link]();
[Link](pixelDensity, pixelDensity);
var controlRadius = 50;
[Link]();
[Link](startX, startY, controlRadius, 0, [Link] * 2, false);
[Link]();
[Link] = "rgba(255, 255, 255, 0.3)";
[Link]();
var offsetX = currentX - startX;
var offsetY = currentY - startY;
var mag = [Link]([Link](offsetX, 2) + [Link](offsetY, 2));
var divisor = mag > controlRadius ? (mag / controlRadius) : 1;
offsetX /= divisor;
offsetY /= divisor;
[Link]();
[Link](startX + offsetX, startY + offsetY, controlRadius *
0.5, 0, [Link] * 2, false);
[Link]();
[Link] = "white";
[Link]();
[Link]();
}

// RENDER PROJECTILES:
function renderProjectiles(layer, xOffset, yOffset) {
for (var i = 0; i < [Link]; ++i) {
tmpObj = projectiles[i];
if ([Link] && [Link] == layer) {
[Link](delta);
if ([Link] && isOnScreen(tmpObj.x-xOffset, tmpObj.y-
yOffset, [Link])) {
[Link]();
[Link](tmpObj.x - xOffset, tmpObj.y -
yOffset);
[Link]([Link]);
renderProjectile(0, 0, tmpObj, mainContext, 1);
[Link]();
}
}
}
}

// RENDER PROJECTILE:
var projectileSprites = {};
function renderProjectile(x, y, obj, ctxt, debug) {
if ([Link]) {
var tmpSrc = [Link][[Link]].src;
var tmpSprite = projectileSprites[tmpSrc];
if (!tmpSprite) {
tmpSprite = new Image();
[Link] = function() {
[Link] = true;
}
[Link] = ".././img/weapons/" + tmpSrc + ".png";
projectileSprites[tmpSrc] = tmpSprite;
}
if ([Link])
[Link](tmpSprite, x - ([Link] / 2), y - ([Link] /
2), [Link], [Link]);
} else if ([Link] == 1) {
[Link] = "#939393";
renderCircle(x, y, [Link], ctxt);
}
}

// RENDER WATER BODIES:

function renderWaterBodies(xOffset, yOffset, ctxt, padding) {
// MIDDLE RIVER:
var tmpW = [Link] + padding;
var tmpY = ([Link] / 2) - yOffset - (tmpW / 2);
if (tmpY < maxScreenHeight && tmpY + tmpW > 0) {
[Link](0, tmpY, maxScreenWidth, tmpW);
}
}

// RENDER GAME OBJECTS:

function renderGameObjects(layer, xOffset, yOffset) {
var tmpSprite, tmpX, tmpY;
for (var i = 0; i < [Link]; ++i) {
tmpObj = gameObjects[i];
if ([Link]) {
tmpX = tmpObj.x + [Link] - xOffset;
tmpY = tmpObj.y + [Link] - yOffset;
if (layer == 0) {
[Link](delta);
}
if ([Link] == layer && isOnScreen(tmpX, tmpY,
[Link] + ([Link]||0))) {
[Link] = [Link]?0.6:1;
if([Link]){
tmpSprite = getItemSprite(tmpObj);

[Link]();
[Link](tmpX, tmpY);
[Link]([Link]);
[Link](tmpSprite, -([Link] /
2), -([Link] / 2));

if([Link]){
[Link] = "#db6e6e";
[Link] = 0.3;
[Link] = 6;
renderCircle(0, 0, [Link], mainContext,
false, true);
}

[Link]();
} else {
tmpSprite = getResSprite(tmpObj);
[Link](tmpSprite, tmpX -
([Link] / 2), tmpY - ([Link] / 2));
}
}
}
}
}
let detect = {
insta: false,
reverse: false,
onetick: false,
spiketick: false,
barbarian: false,
antibull: false,
antibullhit: false,
bowInsta: false,
antiSync: false,
}
// GATHER ANIMATION:
function gatherAnimation(sid, isObjectHit, weapon) {
tmpObj = findPlayerBySID(sid);
if (tmpObj) {
[Link]({player: tmpObj, isObjectHit: isObjectHit, weapon:
weapon});

if(isObjectHit){
[Link]({objects: damageObjects, player: tmpObj,
weapon: weapon});
damageObjects = [];
}

[Link](isObjectHit, weapon);
}
if ([Link](myPlayer.x2, myPlayer.y2, nearestEnemy.x2,
nearestEnemy.y2) <= 400 && [Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) >= 170 && [Link](tmpDir, [Link])
<= [Link]) {
if (([Link] == 12 || [Link] == 13) &&
([Link] == 53 || [Link] == 7)) {
[Link] = true;
} else {
[Link] = false;
}
} else {
[Link] = false;
}
}

// RENDER PLAYERS:
function renderPlayers(xOffset, yOffset, zIndex) {
[Link] = 1;
for (var i = 0; i < [Link]; ++i) {
tmpObj = players[i];
if ([Link] == zIndex) {
[Link](delta);
if ([Link]) {
[Link] += (0.002 * delta);
tmpDir = ((tmpObj == myPlayer) ? getAttackDir() :
[Link]) + [Link];
[Link]();
[Link](tmpObj.x - xOffset, tmpObj.y -
yOffset);
// RENDER PLAYER:
[Link](tmpDir);
renderPlayer(tmpObj, mainContext);
[Link]();
}
}
}
}

// RENDER PLAYER:
function renderPlayer(obj, ctxt) {
ctxt = ctxt || mainContext;
[Link] = outlineWidth;
[Link] = "miter";
var handAngle = ([Link] / 4) * ([Link][[Link]].armS||
1);
var oHandAngle = ([Link] < 0)?
([Link][[Link]].hndS||1):1;
var oHandDist = ([Link] < 0)?
([Link][[Link]].hndD||1):1;

// TAIL/CAPE:
if ([Link] > 0) {
renderTail([Link], ctxt, obj);
}

// WEAPON BELLOW HANDS:

if ([Link] < 0 && ![Link][[Link]].aboveHand) {
renderTool([Link][[Link]],
[Link][[Link]].src, [Link], 0, ctxt);
if ([Link][[Link]].projectile != undefined && !
[Link][[Link]].hideProjectile) {
renderProjectile([Link], 0,

[Link][[Link][[Link]].projectile], mainContext);
}
}

// HANDS:
[Link] = [Link][[Link]];
renderCircle([Link] * [Link](handAngle), ([Link] *
[Link](handAngle)), 14);
renderCircle(([Link] * oHandDist) * [Link](-handAngle *
oHandAngle),
([Link] * oHandDist) * [Link](-handAngle *
oHandAngle), 14);

// WEAPON ABOVE HANDS:

if ([Link] < 0 && [Link][[Link]].aboveHand) {
renderTool([Link][[Link]],
[Link][[Link]].src, [Link], 0, ctxt);
if ([Link][[Link]].projectile != undefined && !
[Link][[Link]].hideProjectile) {
renderProjectile([Link], 0,

[Link][[Link][[Link]].projectile], mainContext);
}
}

// BUILD ITEM:
if ([Link] >= 0) {
var tmpSprite = getItemSprite([Link][[Link]]);
[Link](tmpSprite, [Link] -
[Link][[Link]].holdOffset, -[Link] / 2);
}

// BODY:
renderCircle(0, 0, [Link], ctxt);

// SKIN:
if ([Link] > 0) {
[Link]([Link]/2);
renderSkin([Link], ctxt, null, obj);
}
}

// RENDER SKINS:
var skinSprites = {};
var skinPointers = {};
var tmpSkin;
function renderSkin(index, ctxt, parentSkin, owner) {
tmpSkin = skinSprites[index];
if (!tmpSkin) {
var tmpImage = new Image();
[Link] = function() {
[Link] = true;
[Link] = null;
};
[Link] = ".././img/hats/hat_" + index + ".png";
skinSprites[index] = tmpImage;
tmpSkin = tmpImage;
}
var tmpObj = parentSkin||skinPointers[index];
if (!tmpObj) {
for (var i = 0; i < [Link]; ++i) {
if (hats[i].id == index) {
tmpObj = hats[i];
break;
}
}
skinPointers[index] = tmpObj;
}
if ([Link])
[Link](tmpSkin, -[Link]/2, -[Link]/2,
[Link], [Link]);
if (!parentSkin && [Link]) {
[Link]();
[Link]([Link]);
renderSkin(index + "_top", ctxt, tmpObj, owner);
[Link]();
}
}

// RENDER TAIL:
var accessSprites = {};
var accessPointers = {};
function renderTail(index, ctxt, owner) {
tmpSkin = accessSprites[index];
if (!tmpSkin) {
var tmpImage = new Image();
[Link] = function() {
[Link] = true;
[Link] = null;
};
[Link] = ".././img/accessories/access_" + index + ".png";
accessSprites[index] = tmpImage;
tmpSkin = tmpImage;
}
var tmpObj = accessPointers[index];
if (!tmpObj) {
for (var i = 0; i < [Link]; ++i) {
if (accessories[i].id == index) {
tmpObj = accessories[i];
break;
}
}
accessPointers[index] = tmpObj;
}
if ([Link]) {
[Link]();
[Link](-20 - ([Link]||0), 0);
if ([Link])
[Link]([Link]);
[Link](tmpSkin, -([Link]/2), -([Link]/2),
[Link], [Link]);
[Link]();
}
}

// RENDER TOOL:
var toolSprites = {};
function renderTool(obj, variant, x, y, ctxt) {
var tmpSrc = [Link] + (variant||"");
var tmpSprite = toolSprites[tmpSrc];
if (!tmpSprite) {
tmpSprite = new Image();
[Link] = function() {
[Link] = true;
}
[Link] = ".././img/weapons/" + tmpSrc + ".png";
toolSprites[tmpSrc] = tmpSprite;
}
if ([Link])
[Link](tmpSprite, x+[Link]-([Link]/2), y+[Link]-
([Link]/2), [Link], [Link]);
}

// RENDER GAME OBJECTS:

// GET ITEM SPRITE:

var tmpScale = ([Link] * 0.6);

renderStar(tmpContext, ([Link] == "spikes") ? 5 : 6,
[Link], tmpScale);

[Link]();
[Link]();
[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderStar(tmpContext, [Link] == "spikes" ? 5 : 6,
[Link], tmpScale),
[Link](),
[Link] = 1);

[Link] = "#a5974c";
renderCircle(0, 0, tmpScale, tmpContext);

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderCircle(0, 0, tmpScale, tmpContext),
[Link] = 1);

[Link] = "#c9b758";
renderCircle(0, 0, tmpScale / 2, tmpContext, true);

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderCircle(0, 0, tmpScale / 2, tmpContext, !0),
[Link] = 1);
} else if ([Link] == "windmill" || [Link] == "faster windmill"
|| [Link] == "power mill") {
[Link] = "#a5974c";
renderCircle(0, 0, [Link], tmpContext);

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderCircle(0, 0, [Link], tmpContext),
[Link] = 1);

[Link] = "#c9b758";
renderRectCircle(0, 0, [Link] * 1.5, 29, 4, tmpContext);

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderRectCircle(0, 0, [Link] * 1.5, 29, 4, tmpContext),
[Link] = 1);

[Link] = "#a5974c";
renderCircle(0, 0, [Link] * 0.5, tmpContext);

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderCircle(0, 0, [Link] * .5, tmpContext),
[Link] = 1);
} else if ([Link] == "mine") {
[Link] = "#939393";
renderStar(tmpContext, 3, [Link], [Link]);
[Link]();
[Link]();
[Link] = "#bcbcbc";
renderStar(tmpContext, 3, [Link] * 0.55, [Link] * 0.65);
[Link]();
} else if ([Link] == "sapling") {
for (var i = 0; i < 2; ++i) {
var tmpScale = [Link] * (!i?1:0.5);
renderStar(tmpContext, 7, tmpScale, tmpScale * 0.7);
[Link] = (!i?"#9ebf57":"#b4db62");
[Link]();
if (!i) [Link]();
}
} else if ([Link] == "pit trap") {
[Link] = "#a5974c";
renderStar(tmpContext, 3, [Link] * 1.1, [Link] * 1.1);
[Link]();
[Link]();

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderStar(tmpContext, 3, [Link] * 1.1, [Link] *
1.1),
[Link](),
[Link] = 1);

[Link] = outlineColor;
renderStar(tmpContext, 3, [Link] * 0.65, [Link] * 0.65);
[Link]();

[Link] && (
[Link] = 0.6,
[Link] = [Link] ? "#0000ff" :
"#ff0000",
renderStar(tmpContext, 3, [Link] * .65, [Link]
* .65),
[Link]());
} else if ([Link] == "boost pad") {
[Link] = "#7e7f82";
renderRect(0, 0, [Link]*2, [Link]*2, tmpContext);
[Link]();
[Link]();
[Link] = "#dbd97d";
renderTriangle([Link] * 1, tmpContext);
} else if ([Link] == "turret") {
[Link] = "#a5974c";
renderCircle(0, 0, [Link], tmpContext);
[Link]();
[Link]();
[Link] = "#939393";
var tmpLen = 50;
renderRect(0, -tmpLen/2, [Link] * 0.9, tmpLen, tmpContext);
renderCircle(0, 0, [Link] * 0.6, tmpContext);
[Link]();
[Link]();
} else if ([Link] == "platform") {
[Link] = "#cebd5f";
var tmpCount = 4;
var tmpS = [Link] * 2;
var tmpW = tmpS / tmpCount;
var tmpX = -([Link]/2);
for (var i = 0; i < tmpCount; ++i) {
renderRect(tmpX - (tmpW/2), 0, tmpW, [Link]*2,
tmpContext);
[Link]();
[Link]();
tmpX += tmpS / tmpCount;
}
} else if ([Link] == "healing pad") {
[Link] = "#7e7f82";
renderRect(0, 0, [Link]*2, [Link]*2, tmpContext);
[Link]();
[Link]();
[Link] = "#db6e6e";
renderRectCircle(0, 0, [Link] * 0.65, 20, 4, tmpContext,
true);
} else if ([Link] == "spawn pad") {
[Link] = "#7e7f82";
renderRect(0, 0, [Link]*2, [Link]*2, tmpContext);
[Link]();
[Link]();
[Link] = "#71aad6";
renderCircle(0, 0, [Link] * 0.6, tmpContext);
} else if ([Link] == "blocker") {
[Link] = "#7e7f82";
renderCircle(0, 0, [Link], tmpContext);
[Link]();
[Link]();
[Link]([Link] / 4);
[Link] = "#db6e6e";
renderRectCircle(0, 0, [Link] * 0.65, 20, 4, tmpContext,
true);
} else if ([Link] == "teleporter") {
[Link] = "#7e7f82";
renderCircle(0, 0, [Link], tmpContext);
[Link]();
[Link]();
[Link]([Link] / 4);
[Link] = "#d76edb";
renderCircle(0, 0, [Link] * 0.5, tmpContext, true);
}
tmpSprite = tmpCanvas;
if (!asIcon)
itemSprites[[Link] + ([Link] ? 100 :
([Link] ? ([Link] ? 200 : 300) : 0))] = tmpSprite;
}
return tmpSprite;
}

// RENDER LEAF:
function renderLeaf(x, y, l, r, ctxt) {
var endX = x + (l * [Link](r));
var endY = y + (l * [Link](r));
var width = l * 0.4;
[Link](x, y);
[Link]();
[Link](((x + endX) / 2) + (width * [Link](r +
[Link]/2)),
((y + endY) / 2) + (width * [Link](r +
[Link]/2)), endX, endY);
[Link](((x + endX) / 2) - (width * [Link](r +
[Link]/2)),
((y + endY) / 2) - (width * [Link](r +
[Link]/2)), x, y);
[Link]();
[Link]();
[Link]();
}

// RENDER CIRCLE:
function renderCircle(x, y, scale, tmpContext, dontStroke, dontFill) {
tmpContext = tmpContext||mainContext;
[Link]();
[Link](x, y, scale, 0, 2 * [Link]);
if (!dontFill) [Link]();
if (!dontStroke) [Link]();
}

// RENDER RECTANGLE:
function renderRect(x, y, w, h, ctxt, stroke) {
[Link](x - (w / 2), y - (h / 2), w, h);
if (!stroke)
[Link](x - (w / 2), y - (h / 2), w, h);
}

// RENDER RECTCIRCLE:
function renderRectCircle(x, y, s, sw, seg, ctxt, stroke) {
[Link]();
[Link](x, y);
seg = [Link](seg / 2);
for (var i = 0; i < seg; i++) {
renderRect(0, 0, s * 2, sw, ctxt, stroke);
[Link]([Link] / seg);
}
[Link]();
}

// RENDER BLOB:
function renderBlob(ctxt, spikes, outer, inner) {
var rot = [Link] / 2 * 3;
var x, y;
var step = [Link] / spikes;
var tmpOuter;
[Link]();
[Link](0, -inner);
for (var i = 0; i < spikes; i++) {
tmpOuter = [Link](outer + 0.9, outer * 1.2);
[Link]([Link](rot + step) * tmpOuter, [Link](rot
+ step) * tmpOuter,
[Link](rot + (step * 2)) * inner,
[Link](rot + (step * 2)) * inner);
rot += step * 2;
}
[Link](0, -inner);
[Link]();
}

// RENDER TRIANGLE:
function renderTriangle(s, ctx) {
ctx = ctx||mainContext;
var h = s * ([Link](3)/2);
[Link]();
[Link](0, -h / 2);
[Link]( -s / 2, h / 2);
[Link](s / 2, h / 2);
[Link](0, -h / 2);
[Link]();
[Link]();
}

// PREPARE MENU BACKGROUND:

function prepareMenuBackground() {
var tmpMid = [Link] / 2;
[Link](0, tmpMid, tmpMid + 200, 0, [Link][3], 0);
[Link](1, tmpMid, tmpMid - 480, 0, [Link][3], 0);
[Link](2, tmpMid + 300, tmpMid + 450, 0,
[Link][3], 0);
[Link](3, tmpMid - 950, tmpMid - 130, 0,
[Link][2], 0);
[Link](4, tmpMid - 750, tmpMid - 400, 0,
[Link][3], 0);
[Link](5, tmpMid - 700, tmpMid + 400, 0,
[Link][2], 0);
[Link](6, tmpMid + 800, tmpMid - 200, 0,
[Link][3], 0);
[Link](7, tmpMid - 260, tmpMid + 340, 0,
[Link][3], 1);
[Link](8, tmpMid + 760, tmpMid + 310, 0,
[Link][3], 1);
[Link](9, tmpMid - 800, tmpMid + 100, 0,
[Link][3], 1);
[Link](10, tmpMid - 800, tmpMid + 300, 0,
[Link][4].scale, [Link][4].id, [Link][10]);
[Link](11, tmpMid + 650, tmpMid - 390, 0,
[Link][4].scale, [Link][4].id, [Link][10]);
[Link](12, tmpMid - 400, tmpMid - 450, 0,
[Link][2], 2);
}

// LOAD GAME OBJECT:

function loadGameObject(data) {
for (var i = 0; i < [Link];) {
[Link](data[i], data[i + 1], data[i + 2], data[i + 3],
data[i + 4],
data[i + 5], [Link][data[i + 6]], true,
(data[i + 7]>=0?{sid:data[i + 7]}:null));

if(data[i + 7] >= 0){

[Link](data[i + 7]);
}

i+=8;
}

if(!promiseResolve) return;
promiseResolve(true);
}

// WIGGLE GAME OBJECT:

function wiggleGameObject(dir, sid) {
tmpObj = findObjectBySid(sid);
if(tmpObj){
[Link](tmpObj);

[Link] += [Link] * [Link](dir);

[Link] += [Link] * [Link](dir);
}
}

// SHOOT TURRET:
function shootTurret(sid, dir) {
tmpObj = findObjectBySid(sid);
if(tmpObj){
[Link] = dir;
[Link] += [Link] * [Link](dir+[Link]);
[Link] += [Link] * [Link](dir+[Link]);
}
}

// ADD PROJECTILE:
function addProjectile(x, y, dir, range, speed, indx, layer, sid) {
let projectile = [Link](x, y, dir, range,
speed, indx, null, null, layer);
[Link] = sid;

/*
if(inWindow){
[Link](x, y, dir, range, speed, indx,
null, null, layer).sid = sid;
}
*/

[Link]({projectile: projectile, x: x, y: y, range: range, speed:

speed});
}

// REMOVE PROJECTILE:
function remProjectile(sid, range) {
for(let projectile of projectiles){
if([Link] == sid){
[Link] = range;

[Link](projectile);
if([Link] > 0){
[Link]({objects: damageObjects, projectile:
projectile});
damageObjects = [];
}
}
}
}

// ANIMATE AI:
function animateAI(sid) {
tmpObj = findAIBySID(sid);
if (tmpObj) [Link]();
}

// ADD AI:
function loadAI(data) {
for (var i = 0; i < [Link]; ++i) {
ais[i].forcePos = !ais[i].visible;
ais[i].visible = false;
}
if (data) {
var tmpTime = [Link]();
for (var i = 0; i < [Link];) {
tmpObj = findAIBySID(data[i]);
if (tmpObj) {
[Link] = data[i + 1];
tmpObj.t1 = (tmpObj.t2===undefined)?tmpTime:tmpObj.t2;
tmpObj.t2 = tmpTime;
tmpObj.x1 = tmpObj.x;
tmpObj.y1 = tmpObj.y;
tmpObj.x2 = data[i + 2];
tmpObj.y2 = data[i + 3];
tmpObj.d1 = (tmpObj.d2===undefined)?data[i + 4]:tmpObj.d2;
tmpObj.d2 = data[i + 4];
[Link] = data[i + 5];
[Link] = 0;
[Link] = true;
} else {
tmpObj = [Link](data[i + 2], data[i + 3], data[i +
4], data[i + 1]);
tmpObj.x2 = tmpObj.x;
tmpObj.y2 = tmpObj.y;
tmpObj.d2 = [Link];
[Link] = data[i + 5];
if (![Link][data[i + 1]].name)
[Link] = [Link][data[i + 6]];
[Link] = true;
[Link] = data[i];
[Link] = true;
}
i+=7;
}
}
}

// RENDER AI:
var aiSprites = {};
function renderAI(obj, ctxt) {
var tmpIndx = [Link];
var tmpSprite = aiSprites[tmpIndx];
if (!tmpSprite) {
var tmpImg = new Image();
[Link] = function() {
[Link] = true;
[Link] = null;
};
[Link] = ".././img/animals/" + [Link] + ".png";
tmpSprite = tmpImg;
aiSprites[tmpIndx] = tmpSprite;
}
if ([Link]) {
var tmpScale = [Link] * 1.2 * ([Link]||1);
[Link](tmpSprite, -tmpScale, -tmpScale, tmpScale*2,
tmpScale*2);
}
}

// OBJECT ON SCREEN:
function isOnScreen(x, y, s) {
return (x + s >= 0 && x - s <= maxScreenWidth && y + s >= 0 && y - s <=
maxScreenHeight)
}

// ADD NEW PLAYER:

function addPlayer(data, isYou) {
var tmpPlayer = findPlayerByID(data[0]);
if (!tmpPlayer) {
tmpPlayer = new Player(data[0], data[1], config, UTILS,
projectileManager,
objectManager, players, ais, items, hats,
accessories);
[Link](tmpPlayer);
}

[Link](isYou?moofoll:null);
[Link] = false;
tmpPlayer.x2 = undefined;
tmpPlayer.y2 = undefined;
[Link](data);

primaryReload[[Link]] = 1;
secondaryReload[[Link]] = 1;
turretReload[[Link]] = 1;

if (isYou) {
ePress = false;
autogathering = false;
keyCodeWeapon = 0;

myPlayer = tmpPlayer;
camX = myPlayer.x;
camY = myPlayer.y;
updateItems();
updateStatusDisplay();
updateAge();
updateUpgrades(0);
[Link] = "block";
}
}

// REMOVE PLAYER:
function removePlayer(id) {
for (var i = 0; i < [Link]; i++) {
if (players[i].id == id) {
[Link](i, 1);
break;
}
}
}

// UPDATE PLAYER ITEM VALUES:

function updateItemCounts(index, value) {
if (myPlayer) {
[Link][index] = value;
}
}

// UPDATE PLAYER VALUE:

function updatePlayerValue(index, value, updateView) {
if (myPlayer) {
myPlayer[index] = value;
if (updateView)
updateStatusDisplay();
}
}

let autoMills = false;

let autoBreak = false;

let autoBreakAngle;
let breakObject;
let nearestTrap;

let enemiesNear;
let ePress = false;
let checkGather = false;
let lastGatherState = false;

let damageTick = 0;
let tick = 0;
let hits = [];
let shoots = [];
let removeShoots = [];

let primaryReload = [];

let secondaryReload = [];
let turretReload = [];

let placeTick = 0;
let predictObjects = [];
let prePlaceObjects = [];
let predictEnemyTraps = [];

let predictWeapon = 0;
let keyCodeWeapon = 0;

let healing = false;

let autoReload = false;

let deathDamages = [];

let spikeDmg = 0;
let spikeDmgCount = 0;
let spikeDamages = [];

let damageObjects = [];

let objectHits = [];
let objectShoots = [];

let antiReverse = [];

let antiInsta = [];

let damageByPoisonTick = 0;
let damagesByTurrets = [];
let damagesByHits = [];
let damagesByShoots = [];
let damages = [];

let qPress = false;

let spikeKnockPosLine = {};

let visibleObjects = [];

let enemySpikes;
let antiVelocitySpikeSync;

let trapBreaked = false;

let trapBreakedTick = 0;

let soldierAnti = false;

let predictMoveAngle = null;

let lastMoveAngle = null;

let antiSpikeTick;
let nearestEnemiesCount = 0;
let antiTick = false;
let antiTickTimeout;
let deadPlayers = [];
let breakObjects = [];
let player;
let playerSID;
let near = [];
let nears = [];
let syncrlist = [];
let antiBoostTick = false;

let predictDamage = {
spike: 0,
poison: 0,
player: 0,
};

let antiPush = false;

let autoPush = false;

let predictMove = [];

let moveVectors = {
87: [0, -1],
83: [0, 1],
65: [-1, 0],
68: [1, 0],
};

let autoaim = false;

let instaKill = [];

let insta = {
primary: false,
secondary: false
}

let spamPrePlacer = false;

let prePlaceInterval;

function resetPredictDamages(){
for(const i in predictDamage){
predictDamage[i] = 0;
}
}

function getPredictDamage(){
let damage = 0;
for(let i in predictDamage){
damage += predictDamage[i];
}

return damage;
}

function canVelocitySpikeTick(){
if(!nearestEnemy) return;

let spikes = [Link](object => [Link] > 5 && [Link]

< 10 && ([Link] == [Link] || isAlly([Link])));
let trap = [Link](object => [Link] == 15 &&
[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= 50 &&
([Link] == [Link] || isAlly([Link])))[0];

let isEnemyInSpike = false;

let posX = nearestEnemy.x2 + 111 * (.3 +

([Link][[Link][0]].knock || 0)) *
[Link](Math.atan2(nearestEnemy.y2-myPlayer.y2, nearestEnemy.x2-myPlayer.x2));
let posY = nearestEnemy.y2 + 111 * (.3 +
([Link][[Link][0]].knock || 0)) *
[Link](Math.atan2(nearestEnemy.y2-myPlayer.y2, nearestEnemy.x2-myPlayer.x2));

for(let object of spikes){

if([Link]([Link], [Link],
object.x, object.y) < (35 + [Link])){
isEnemyInSpike = true;
} else {
if(trap){
if([Link] > 0){
isEnemyInSpike = true;
}
} else {
if([Link](posX, posY, object.x, object.y) < (35
+ [Link])){
isEnemyInSpike = true;
}
}
}

if(isEnemyInSpike) break;
}

if(isEnemyInSpike){
return ([Link][0] == 4 || [Link][0] == 5) &&
[Link]([Link], [Link], [Link],
[Link]) <= (35 * 1.8 + [Link][[Link][0]].range)
&& primaryReload[[Link]] == 1 && !autoaim;
}
}

function canSpikeTick(object){
return ([Link] > 5 && [Link] < 10) && nearestEnemy &&
[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= (35 +
[Link])
&& ([Link][0] == 4 || [Link][0] == 5) &&
primaryReload[[Link]] == 1 && secondaryReload[[Link]] == 1 && !autoaim
&& !trapBreaked;
}

function canPredictSpikeTick(object){
if(!canSpikeTick(object)) return false;

let trap = [Link](object => [Link] == 15 &&

[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= 50 &&
([Link] == [Link] || isAlly([Link])))[0];
if(trap){
let damage = 0;
let weapon = null;

if([Link][1] == 10){
if(secondaryReload[[Link]] == 1){
weapon = [Link][1];
}
}

if(weapon != null && [Link](myPlayer.x2, myPlayer.y2,

trap.x, trap.y) <= ([Link] + [Link][weapon].range)){
damage = [Link][weapon].dmg *
([Link][weapon].sDmg || 1) *
[Link][([Link][weapon] || 1)].val *
(isBoughtHat(40, 0) ? 3.3 : 1);
}

if([Link] <= damage){

return true;
}
}
}

function place(id, angle = Math.atan2(mouseY - (screenHeight / 2), mouseX -

(screenWidth / 2))){
selectToBuild(id);
sendAtck(1, angle);
sendAtck(0, angle);
selectWeapon(predictWeapon);
}

function heal(value){
for(let i = 0;i < value;i += [Link][[Link][0]].heal){
place([Link][0], null);
}
}
function isBoughtHat(id, type){
if(type){
return [Link][id];
} else {
return [Link][id];
}
}

function hat(id){
if([Link] != id){
if(id == 0){
storeEquip(id, 0);
} else {
if(isBoughtHat(id, 0)){
storeEquip(id, 0);
}
}
}
}

function acc(id){
if([Link] != id){
if(id == 0){
storeEquip(id, 1);
} else {
if(isBoughtHat(id, 1)){
storeEquip(id, 1);
}
}
}
}

function getConfig(id, angle, velocity){

return {
x: (velocity ? [Link] : myPlayer.x2) + (35 +
[Link][id].scale + ([Link][id].placeOffset || 0)) * [Link](angle),
y: (velocity ? [Link] : myPlayer.y2) + (35 +
[Link][id].scale + ([Link][id].placeOffset || 0)) * [Link](angle),
scale: [Link][id].scale,
}
}

function canPlace(id, angle, objects, velocity){

if(isItemLimit(id)) return false;

let config = getConfig(id, angle, velocity);

if([Link](config.x, config.y, [Link],
0.6, id, false, myPlayer, objects ? objects : visibleObjects)) return true;

return false;
}

function getPredictWeapon(){
if(autoBreak){
if([Link][1] != 10){
return [Link][0];
}
if(nearestTrap){
if(breakObject == nearestTrap){
if([Link][[Link][0]].speed <= 400 &&
[Link] <= [Link][[Link][0]].dmg){
return [Link][0];
}

return [Link][1];
} else {
if([Link][[Link][0]].speed <= 400 &&
[Link] <= [Link][[Link][0]].dmg
&& [Link](myPlayer.x2, myPlayer.y2,
breakObject.x, breakObject.y) <= ([Link][[Link][0]].range +
[Link])){
return [Link][0];
}

if([Link](myPlayer.x2, myPlayer.y2,
breakObject.x, breakObject.y) <= ([Link][[Link][1]].range +
[Link])){
return [Link][1];
} else {
return [Link][0];
}
}
} else {
return [Link][1];
}
} else {
if(secondaryReload[[Link]] < 1){
return [Link][1];
} else {
if(primaryReload[[Link]] < 1){
return [Link][0];
}
}
}

return keyCodeWeapon;
}

function addPredictObject(id, angle, preplace){

let config = getConfig(id, angle);
for(let object of predictObjects){
if([Link](config.x, config.y, object.x, object.y) <
([Link] + [Link])) return;
}

[Link]({id: id, angle: angle, name: [Link][id].name,

x: config.x, y: config.y, scale: [Link], preplace: preplace});
}

function isItemLimit(id){
let group = [Link][id].group;
let limit = ([Link] || 99);

if([Link][[Link]] >= limit){

return true;
}
}

function lineInCircle(x, y, x2, y2, circleX, circleY, scale){

let lineVec = {x: x2 - x, y: y2 - y};
let lineToCircleVec = {x: circleX - x, y: circleY - y};

let projection = (lineToCircleVec.x * lineVec.x + lineToCircleVec.y *

lineVec.y) / (lineVec.x * lineVec.x + lineVec.y * lineVec.y);
let closestPoint = {x: x + projection * lineVec.x, y: y + projection *
lineVec.y};

if(closestPoint.x >= [Link](x, x2) && closestPoint.x <= [Link](x,

x2) && closestPoint.y >= [Link](y, y2) && closestPoint.y <= [Link](y, y2)){
return [Link](closestPoint.x, closestPoint.y, circleX,
circleY) < scale;
}
}

function isAlly(sid){
if([Link]){
for(var i = 0; i < [Link];i += 2){
if(alliancePlayers[i] == sid){
return true;
}
}
}
}

function checkEnemyTraps(id, angle){

let config = getConfig(id, angle);
for(let object of predictEnemyTraps){
if([Link](config.x, config.y, object.x, object.y) <
([Link] + [Link])) return false;
}

return true;
}

function addEnemyTrap(id, angle){

let config = getConfig(id, angle);
if(checkEnemyTraps(id, angle)){
[Link]({id: 15, x: config.x, y: config.y, scale:
[Link], tick: tick});
}
}

let lastPrePlaceObject = null;

let removedObjects = [];

function updateAngles(id){
const angles = [];
for(let i = 0;i < [Link] / 69/*200*/; i++){
const angle = [Link](i * (360 / 200));
[Link]({id: id, angle: angle, placeable: canPlace(id,
angle), ...getConfig(id, angle)});
}

getPerfectAngles(angles);
checkPredictObjects(angles);
}

function updateAngles2(id){
const angles = [];
for(let i = 0;i < 36;i++){
const angle = [Link](i * (360 / 36));
[Link]({id: id, angle: angle, placeable: canPlace(id, angle)
&& checkEnemyTraps(id, angle), ...getConfig(id, angle)});
}

getPerfectAngles(angles);
checkPredictObjects(angles);
}

function checkPredictObjects(angles){
for(let object of [Link]((object) => [Link])){
if(!isAutoPlaceAngle(object)) continue;
addPredictObject([Link], [Link], false);
}

for(let object of [Link]((object) => [Link])){

if(!isAutoPlaceAngle(object)) continue;
addPredictObject([Link], [Link], false);
}
}

function getPrePlaceAngles(id, customObjects){

const angles = [];
for(let i = 0;i < 200;i++){
const angle = [Link](i * (360 / 200));
[Link]({id: id, angle: angle, placeable: canPlace(id, angle,
customObjects), ...getConfig(id, angle)});
}

getPerfectAngles(angles);
return angles;
}

function getPerfectAngles(angles){
for(let i in angles){
angles[i].perfect = false;

if(i < 1) continue;

if(angles[i].placeable && !angles[i - 1].placeable){

angles[i].perfect = true;
}

if(angles[i - 1].placeable && !angles[i].placeable){

angles[i - 1].perfect = true;
}
}
}

function isPrePlaceAngle(config, prePlaceObject){

if(!nearestEnemy) return false;

if([Link] == [Link][2] && !isItemLimit([Link][2])){

const trap = [Link]((object) => [Link] == 15 &&
[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= 50 &&
([Link] == [Link] || isAlly([Link])))[0];
if(trap && prePlaceObject != trap){
return true;
} else {
if(nearestTrap) return false;

if([Link](config.x, config.y, [Link],

[Link]) <= (35 + [Link])){
let angle = Math.atan2([Link]-config.y,
[Link]-config.x);

let posX = config.x + 200 * [Link](angle);

let posY = config.y + 200 * [Link](angle);

let spikes = [Link](object => [Link] > 5

&& [Link] < 10 && ([Link] == [Link] ||
isAlly([Link])));
for(let object of spikes){
if(prePlaceObject != object &&
[Link](object.x - [Link], object.y - [Link], object.x +
[Link], object.y + [Link], config.x, config.y, posX, posY)){
return [Link][2];
}
}
} else {
if([Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) > 300) return false;
if([Link](config.x - [Link], config.y -
[Link], config.x + [Link], config.y + [Link], myPlayer.x2,
myPlayer.y2, nearestEnemy.x2, nearestEnemy.y2)) return false;

let spikes = [Link](object => [Link] > 5

&& [Link] < 10 && ([Link] == [Link] ||
isAlly([Link])));
let nearestSpike = [Link]((a, b) =>
[Link](config.x, config.y, a.x, a.y) - [Link](config.x,
config.y, b.x, b.y))[0];

const getAvoidSpikesCount = function(){

let count = 0;
for(let object of predictObjects){
if([Link] != [Link][2]) continue;
count++;
}

return count;
}

if(getAvoidSpikesCount() >= 1) return false;

if(nearestSpike){
if([Link](config.x, config.y,
nearestSpike.x, nearestSpike.y) > ([Link] + [Link] + 50)){
return true;
}
} else {
return true;
}
}
}
}

if([Link] == [Link][4] && !isItemLimit([Link][4])){

if([Link](myPlayer.x2, myPlayer.y2, nearestEnemy.x2,
nearestEnemy.y2) > 300) return false;
return true;
}

return false;
}

function isAutoPlaceAngle(config){
if(!nearestEnemy) return false;

if([Link] == [Link][2] && !isItemLimit([Link][2])){

const trap = [Link]((object) => [Link] == 15 &&
[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= 50 &&
([Link] == [Link] || isAlly([Link])))[0];
if(trap){
if([Link](config.x, config.y, nearestEnemy.x2,
nearestEnemy.y2) <= (35 + [Link])){
return true;
} else {
if([Link](config.x - [Link], config.y -
[Link], config.x + [Link], config.y + [Link], myPlayer.x2,
myPlayer.y2, trap.x, trap.y)) return false;

if([Link](config.x, config.y, [Link],

[Link]) <= (35 + [Link])){
let angle = Math.atan2([Link]-config.y,
[Link]-config.x);

let posX = config.x + 200 * [Link](angle);

let posY = config.y + 200 * [Link](angle);

let spikes = [Link](object => [Link] > 5

&& [Link] < 10 && ([Link] == [Link] ||
isAlly([Link])));
for(let object of spikes){
if([Link](object.x - [Link], object.y -
[Link], object.x + [Link], object.y + [Link], config.x, config.y,
posX, posY)){
return true;
}
}
} else {
if([Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) > 300) return false;
if([Link](config.x - [Link], config.y -
[Link], config.x + [Link], config.y + [Link], myPlayer.x2,
myPlayer.y2, nearestEnemy.x2, nearestEnemy.y2)) return false;

let spikes = [Link](object => [Link] > 5

&& [Link] < 10 && ([Link] == [Link] ||
isAlly([Link])));
let nearestSpike = [Link]((a, b) =>
[Link](config.x, config.y, a.x, a.y) - [Link](config.x,
config.y, b.x, b.y))[0];

const getAvoidSpikesCount = function(){

let count = 0;
for(let object of predictObjects){
if([Link] != [Link][2]) continue;
count++;
}

return count;
}

if(getAvoidSpikesCount() >= 1) return false;

if(nearestSpike){
if([Link](config.x, config.y,
nearestSpike.x, nearestSpike.y) > ([Link] + [Link] + 50)){
return true;
}
} else {
return true;
}
}
}
}

if([Link] == [Link][4] && !isItemLimit([Link][4])){

if([Link](myPlayer.x2, myPlayer.y2, nearestEnemy.x2,
nearestEnemy.y2) > 300) return false;

const trap = [Link]((object) => [Link] == 15 &&

[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= 50 &&
([Link] == [Link] || isAlly([Link])))[0];
if(trap && [Link](myPlayer.x2, myPlayer.y2, trap.x,
trap.y) <= (35 + [Link] + 50)){
return false;
} else {
return true;
}
}

return false;
}

function getPrePlaceObject(){
let findObject;

if(autogathering){
if((predictWeapon < 9 && primaryReload[[Link]] == 1) ||
(predictWeapon > 8 && secondaryReload[[Link]] == 1)){
let dmg = [Link][predictWeapon].dmg *
([Link][predictWeapon].sDmg || 1) *
([Link][[Link][predictWeapon]].val) *
(isBoughtHat(40, 0) ? 3.3 : 1);

findObject = [Link]((object) =>

([Link]([Link], [Link], object.x, object.y) -
[Link]) <= [Link][predictWeapon].range
&&
[Link]([Link](object.x, object.y, [Link],
[Link]), getAttackDir()) <= [Link]
&& [Link] <=
dmg).sort((a, b) => [Link](a.x, a.y, nearestEnemy.x2, nearestEnemy.y2) -
[Link](b.x, b.y, nearestEnemy.x2, nearestEnemy.y2))[0];
}
}

if(nearestEnemy && !findObject){

if(weapon != null){
let dmg = [Link][weapon].dmg *
([Link][weapon].sDmg || 1) *
([Link][[Link][weapon]].val || 1) * 3.3;

findObject = [Link]((object) => !

[Link] && [Link](nearestEnemy.x2, nearestEnemy.y2,
object.x, object.y) <= ([Link] + [Link][weapon].range)
&& [Link] <=
dmg).sort((a, b) => [Link](a.x, a.y, nearestEnemy.x2, nearestEnemy.y2) -
[Link](b.x, b.y, nearestEnemy.x2, nearestEnemy.y2))[0];
}
}

if(findObject){
spamPrePlacer = true;
}

return findObject;
}

function getPredictObjects(){
// FIX STACK PACKETS
if([Link] > 0){
if(lastPrePlaceObject && [Link]((sid) =>
[Link] == sid)){
for(const object of predictObjects){
if(![Link]) continue;

addEnemyTrap([Link], [Link]);
placeTick = tick;
}
}

removedObjects = [];
}

predictObjects = [];

// PRE PLACER
lastPrePlaceObject = null;
spamPrePlacer = false;

if(nearestEnemy && [Link](myPlayer.x2, myPlayer.y2,

nearestEnemy.x2, nearestEnemy.y2) < 300 && !(nearestTrap && spikeDmgCount > 0)){
let findObject = getPrePlaceObject();

let customObjects = [];

for(let object of visibleObjects){
[Link](object);
}

if(findObject){
[Link]([Link](findObject), 1);

let findAngle;

const spikeAngles = getPrePlaceAngles([Link][2],

customObjects);
const trapAngles = getPrePlaceAngles([Link][4] || 15,
customObjects);

const getFindAngle = function(findAngleFunc){

if(findAngle) return;

findAngleFunc();
if(findAngle){
addPredictObject([Link], [Link], true);
}
}

getFindAngle(function(){
const object = [Link]((object) =>
[Link]).sort((a, b) => [Link](findObject.x, findObject.y, a.x,
a.y) - [Link](findObject.x, findObject.y, b.x, b.y))[0];
if(object && isPrePlaceAngle(object, findObject)){
findAngle = object;
}
});

for(let i in predictObjects){
if(!predictObjects[i].preplace) continue;

lastPrePlaceObject = findObject;
break;
}
}
}
/* object filtering */
//let enemyTrapped = [Link](tmp => [Link] && [Link]
&& isAlly([Link]) && [Link](tmp, 0, 2) <= [Link] + [Link]()
+ 15).sort((a, b) => {
// return [Link](a, 0, 2) - [Link](b, 0, 2);
//})[0];
// AUTO PLACE
if([Link]){
if(nearestTrap){
updateAngles2([Link][2]);
updateAngles2([Link][4] || 15);
} else {
updateAngles2([Link][2]);
updateAngles2([Link][4] || 15);

setPlaceTick();
if((tick - placeTick) >= 3) {
updateAngles([Link][2]);
updateAngles([Link][4] || 15);
}
}
}

setPlaceTick();

// SHIT AUTO MILLS

if(autoMills && lastMoveAngle != null && !nearestTrap){
let angle = lastMoveAngle + [Link](180);
if(canPlace([Link][3], angle) &&
checkEnemyTraps([Link][3], angle)){
if(canPlace([Link][3], angle) &&
checkEnemyTraps([Link][3], angle)){
addPredictObject([Link][3], angle, false);
}

if(canPlace([Link][3], angle -
[Link]([Link][[Link][3]].scale +
[Link][[Link][3]].scale / 2)) && checkEnemyTraps([Link][3],
angle - [Link]([Link][[Link][3]].scale +
[Link][[Link][3]].scale / 2))){
addPredictObject([Link][3], angle -
[Link]([Link][[Link][3]].scale +
[Link][[Link][3]].scale / 2), false);
}

if(canPlace([Link][3], angle +
[Link]([Link][[Link][3]].scale +
[Link][[Link][3]].scale / 2)) && checkEnemyTraps([Link][3],
angle + [Link]([Link][[Link][3]].scale +
[Link][[Link][3]].scale / 2))){
addPredictObject([Link][3], angle +
[Link]([Link][[Link][3]].scale +
[Link][[Link][3]].scale / 2), false);
}
}
}
}

function setPlaceTick(){
for(let i in predictObjects){
if(predictObjects[i].preplace) continue;

placeTick = tick;
break;
}
}

function getHatInStore(id){
for(let hat of hats){
if([Link] == id){
return hat;
}
}

return {};
}

function getAccInStore(id){
for(let acc of accessories){
if([Link] == id){
return acc;
}
}

return {};
}

function doWeaponStuff(player){
if([Link] < 0){
[Link][[Link]] = [Link];

if([Link] < 9){

if(player != myPlayer){
[Link][0] = [Link];
}

primaryReload[[Link]] = [Link](1,
primaryReload[[Link]] + (player.t2 - player.t1) /
[Link][[Link]].speed);
} else {
if(player != myPlayer){
[Link][1] = [Link];
}

if([Link] != 11){
secondaryReload[[Link]] = [Link](1,
secondaryReload[[Link]] + (player.t2 - player.t1) /
[Link][[Link]].speed);
}
}
}

if(damage > 0){

[Link] = [Link]();

if(tmpObj == myPlayer){
damageTick = (tick + 1);

[Link]([Link](damage, 2));
[Link]({damage: [Link](damage, 2), tick:
damageTick});
} else {
if([20, 30, 35, 45, (20 * .75), (30 * .75), (35 * .75), (45
* .75)].includes(damage)){
[Link] = damage;
}
}
} else {
if([Link]){
let o = [Link]() - [Link];
if(o <= 120){
[Link] = [Link] + 1;
} else {
[Link] = [Link](0, [Link] - 2);
}

[Link] = null;
}

if(tmpObj == myPlayer && [Link] == 100){

deathDamages = [];
spikeDmg = 0;
}
}
}
}

function projectileHandle(projectile){
let player = [Link];
if(player == null) return;

if(!isAlly([Link])){
if([Link] == "turret" && [Link](myPlayer.x2,
myPlayer.y2, player.x2, player.y2) > 200 && [Link](myPlayer.x2,
myPlayer.y2, player.x2, player.y2) < 300
&& canShoot(projectile) && primaryReload[[Link]] == 1){
addChatLog(`Mod: Anti Tick`, "#ffffff");
antiOneTick([Link](myPlayer.x2, myPlayer.y2,
projectile.x, projectile.y) / [Link]);
}
}
}

function canShoot(projectile){
let config = {
x: projectile.x + [Link] * [Link]([Link]),
y: projectile.y + [Link] * [Link]([Link]),
sid: [Link] != null ? [Link] :
[Link],
};

if([Link] == [Link] || isAlly([Link])){

return false;
}

if([Link](myPlayer.x2 - 35, myPlayer.y2 - 35, myPlayer.x2 +

35, myPlayer.y2 + 35, projectile.x, projectile.y, config.x, config.y)){
let filterObjects = [];
let types = [10, 11, 12, 17];
for(let object of visibleObjects){
if([Link]) continue;

if([Link] == "turret"){
if([Link] != null && [Link] ==
[Link]) continue;

if([Link]([Link]) || ([Link] != null &&

[Link] != 2)){
[Link](object);
}
} else {
[Link](object);
}
}

let nearestFind = [Link]((object) =>

[Link](object.x - [Link](), object.y - [Link](),
object.x + [Link](), object.y + [Link](), projectile.x,
projectile.y, config.x, config.y))
.sort((a, b) => [Link](a.x, a.y, projectile.x,
projectile.y) - [Link](b.x, b.y, projectile.x, projectile.y))[0];

if(nearestFind && [Link](nearestFind.x, nearestFind.y,

projectile.x, projectile.y) < [Link](myPlayer.x2, myPlayer.y2,
projectile.x, projectile.y)){
return false;
}
return true;
}

return false;
}

function antiOneTick(speed){
antiTick = true;
clearTimeout(antiTickTimeout);
antiTickTimeout = setTimeout(function(){
antiTick = false;
}, speed);
}

function distributionDamages(object){
if([Link] == "hit"){
const {weapon, player} = object;

let damage = [Link][weapon].dmg *

[Link][[Link][weapon]].val;

damage *= (getHatInStore([Link]).dmgMultO || 1);

damage *= (getAccInStore([Link]).dmgMultO || 1);

damage *= (getHatInStore([Link]).dmgMult || 1);

damage = [Link](damage, 2);

for(let i in damages){
if(damages[i] == damage){
[Link]({damage: damage, player: player, weapon:
weapon});
[Link](i, 1);

break;
}
}
} else if([Link] == "shoot"){
const {projectile} = object;

let damage = [Link] *

(getHatInStore([Link]).dmgMult || 1);
damage = [Link](damage, 2);

for(let i in damages){
if(damages[i] == damage){
[Link]({projectile: projectile, damage:
damage});
[Link](i, 1);

break;
}
}
} else if([Link] == "spikes"){
for(let damage of damages){
if(damage == 20 || damage == 30 || damage == 35 || damage == 45
|| damage == (20 * .75) || damage == (30 * .75) || damage == (35 * .75) || damage
== (45 * .75)){
[Link](damage);
}
}

for(let damage of spikeDamages){

[Link]([Link](damage), 1);
}
}
}

function antiInstaFc(object){
const {type, player} = object;
let damage = 0;

if(!player) return;

(function(){
if(nearestTrap){
let dmg = 0;

for(let player of players){

let weapon = null;

if([Link][1] == 10 && secondaryReload[[Link]]

== 1){
weapon = [Link][1];
} else {
if(primaryReload[[Link]] == 1){
weapon = [Link][0];
}
}

if(weapon != null && [Link](player.x2,

player.y2, nearestTrap.x, nearestTrap.y) <= ([Link] +
[Link][weapon].range)){
dmg += [Link][weapon].dmg *
([Link][weapon].sDmg || 1) *
([Link][[Link][weapon]].val || 1) * ([Link] ==
[Link] ? (isBoughtHat(40, 0) ? 3.3 : 1) : 3.3);
}
}

if([Link] <= dmg){

if([Link] < 45){
[Link] = 45;
}
}
}
})();

if(type == "normal"){
let secondaryWeapon = [Link][1] ? [Link][1] : 15;
if(secondaryReload[[Link]] == 1){
if([Link][secondaryWeapon].projectile != undefined){
damage +=
[Link][[Link][secondaryWeapon].projectile].dmg;
} else {
damage += [Link][secondaryWeapon].dmg *
[Link][[Link][secondaryWeapon]].val;
}
(function(){
let damage = 0;
let knock = 200;

let posX = myPlayer.x2 + knock *

[Link](Math.atan2(myPlayer.y2-player.y2, myPlayer.x2-player.x2));
let posY = myPlayer.y2 + knock *
[Link](Math.atan2(myPlayer.y2-player.y2, myPlayer.x2-player.x2));

for(let object of [Link]((object) =>

[Link](posX, posY, object.x, object.y) < (35 + [Link])
||
lineInCircle(myPlayer.x2, myPlayer.y2, posX, posY, object.x, object.y, (35 +
[Link])))){
damage += [Link][[Link]].dmg;
}

if([Link] < damage){

[Link] = damage;
}

if(damage > 0 && 100 <= getPredictDamage()){

antiVelocitySpikeSync = true;
}
})();
}

if(turretReload[[Link]] >= (2500 - 111 * 2) / 2500){

damage += 25;
}

[Link] += damage;
if(nearestEnemiesCount > 1){
healing = true;
}

antiInsta[[Link]] = true;
} else if(type == "reverse"){
(function(){
if(antiSpikeTick){
if([Link] < 45){
[Link] = 45;
}
}
})();

let primaryWeapon = [Link][0] ? [Link][0] : null;

let primaryVariant = 0;

if(primaryWeapon != null){
primaryVariant = [Link][primaryWeapon];
} else {
primaryVariant = 3;
primaryWeapon = 5;
}

if(primaryReload[[Link]] == 1){
damage += [Link][primaryWeapon].dmg * 1.5 *
[Link][primaryVariant].val;

(function(){
let damage = 0;
let knock = 200;

let posX = myPlayer.x2 + knock *

[Link](Math.atan2(myPlayer.y2-player.y2, myPlayer.x2-player.x2));
let posY = myPlayer.y2 + knock *
[Link](Math.atan2(myPlayer.y2-player.y2, myPlayer.x2-player.x2));

for(let object of [Link]((object) =>

[Link](posX, posY, object.x, object.y) < (35 + [Link])
||
lineInCircle(myPlayer.x2, myPlayer.y2, posX, posY, object.x, object.y, (35 +
[Link])))){
damage += [Link][[Link]].dmg;
}

if([Link] < damage){

[Link] = damage;
}

if(damage > 0 && 100 <= getPredictDamage()){

antiVelocitySpikeSync = true;
}
})();
}

(function(){
let wasTurretDamage = false;
for(let i in damagesByTurrets){
let {damage, projectile} = damagesByTurrets[i];
if([Link] != null && [Link] ==
player){
wasTurretDamage = true;
}
}

if(!wasTurretDamage && turretReload[[Link]] == 0){

damage += 25;
}
})();

[Link] += damage;
if(nearestEnemiesCount > 1){
healing = true;
}

antiReverse[[Link]] = true;
}
}

function changeObjectHealth(player, weapon, damageObjects){

let dmg = [Link][weapon].dmg * ([Link][weapon].sDmg || 1)
* ([Link] == 40 ? 3.3 : 1) *
[Link][[Link][weapon]].val;
for(let object of damageObjects){
[Link] -= dmg;
}
}

function checkBuildingDamage(projectile, damageObjects){

let config = {
x: projectile.x + [Link] * [Link]([Link]),
y: projectile.y + [Link] * [Link]([Link]),
};

for(let object of damageObjects){

if(![Link] && [Link](object.x -
[Link], object.y - [Link], object.x + [Link], object.y +
[Link], projectile.x, projectile.y, config.x, config.y)){
if([Link] == 3){
[Link] -= [Link];
}
}
}
}

function isSpikeCollisionEnemy(spike){
if([Link] > 0){
return true;
}
}

function canAutoPush(){
if(lineInCircle(myPlayer.x2, myPlayer.y2, pushPositions.x,
pushPositions.y, nearestEnemy.x2, nearestEnemy.y2, 35)){
return false;
}

for(let object of visibleObjects){

if([Link] == 15 && ([Link] == [Link] ||
isAlly([Link]))) continue;

if((([Link] > 5 && [Link] < 10) && [Link] !=

[Link] && !isAlly([Link])) || [Link] == 16 || [Link] == 22){
if(lineInCircle(myPlayer.x2, myPlayer.y2, pushPositions.x,
pushPositions.y, object.x, object.y, 35 + [Link](.6, [Link]))){
return false;
}
} else {
if(lineInCircle(myPlayer.x2, myPlayer.y2, pushPositions.x,
pushPositions.y, object.x, object.y, [Link](.6, [Link]) * .75)){
return false;
}
}
}

return true;
}

let antiPushAngle;
function isNearestEnemyPushPlayer(){
if(!nearestEnemy) return false;
if([Link]((object) => [Link] == 15 &&
[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) <= 50 &&
([Link] == [Link] || isAlly([Link])))[0]) return false;
if((nearestTrap && spikeDmgCount < 1) && ([Link][0] == 6 ||
[Link][0] == 7) && !antiSpikeTick){
const nearestSpike = [Link]((a, b) =>
[Link](myPlayer.x2, myPlayer.y2, a.x, a.y) -
[Link](myPlayer.x2, myPlayer.y2, b.x, b.y))[0];

if((nearestTrap && nearestSpike)

&& [Link](nearestSpike.x, nearestSpike.y,
nearestTrap.x, nearestTrap.y) <= (35 + [Link] + [Link])
&& [Link](myPlayer.x2, myPlayer.y2,
[Link], [Link]) <= (35 * 1.8 +
[Link][[Link][0]].range)){
antiPushAngle = Math.atan2(nearestEnemy.y2-myPlayer.y2,
nearestEnemy.x2-myPlayer.x2);
return true;
}
}

return false;
}

function updatePredictEnemyTraps(){
let objects = [];
for(let trap of predictEnemyTraps){
if([Link]((object) => [Link](trap.x,
trap.y, object.x, object.y) < ([Link] + [Link](.6, [Link]))) ||
(tick - [Link]) >= (3 * 10)){
[Link](trap);
}
}

for(let object of objects){

[Link]([Link](object), 1);
}
}

let spawnedObjectSids;
let promiseResolve;
let isAutoFollowOn = false;
let targetPlayerId = null;
const CLOSE_DISTANCE = 80;
const FAR_DISTANCE = 100;
let altPlayerManager = {
activator: [],
iframe: null,
iframeActive: false,
mode: 'sync',
};
[Link]('keydown', (e) => {
if ([Link] === 'eleol' && [Link]() !==
"chatbox") {
[Link]([Link]());
let recentPresses = [Link](g =>
[Link]() - g < 1000).length;

if (recentPresses === 3) {
if ([Link]) {
[Link]();
[Link] = null;
[Link] = false;
} else {
[Link] = [Link]('iframe');
[Link] = [Link] + '?
isAltPlayer=true';
[Link] =
`position:fixed;top:0%;right:0%;bottom:0%;left:0%;z-
index:9999;width:75%;height:75%;display:block;`;
[Link]([Link]);
[Link] = true;
}
[Link] = [];
} else if (recentPresses === 1) {
if ([Link]) {
[Link] =
([Link] === 'block') ? 'none' : 'block';
}
}
}
});

initializeWeights(input, output) {
return [Link]({ length: input }, () => [Link]({ length:
output }, () => [Link]() * 2 - 1));
}

initializeBias(size) {
return [Link]({ length: size }, () => [Link]() * 2 - 1);
}

sigmoid(x) {
return 1 / (1 + [Link](-x));
}

sigmoidDerivative(x) {
return x * (1 - x);
}

feedForward(input) {
[Link] = [Link]([Link]([Link](input,
this.weights1), this.bias1));
[Link] = [Link]([Link]([Link]([Link],
this.weights2), this.bias2));
return [Link];
}

addBias(matrix, bias) {
return [Link]((val, idx) => val + bias[idx]);
}

multiply(input, weights) {
return weights[0].map((_, i) => [Link]((sum, x, j) => sum + x
* weights[j][i], 0));
}

backpropagate(input, expected, learningRate) {

const outputError = [Link]((val, idx) => val -
[Link][idx]);
const outputDelta = [Link]((val, idx) => val *
[Link]([Link][idx]));

const hiddenError = [Link](outputDelta,

[Link](this.weights2));
const hiddenDelta = [Link]((val, idx) => val *
[Link]([Link][idx]));

this.weights2 = [Link]([Link], outputDelta,

this.weights2, learningRate);
this.weights1 = [Link](input, hiddenDelta,
this.weights1, learningRate);

this.bias2 = [Link](this.bias2, outputDelta,

learningRate);
this.bias1 = [Link](this.bias1, hiddenDelta,
learningRate);
}

transpose(matrix) {
return matrix[0].map((_, i) => [Link](row => row[i]));
}

adjustWeights(input, delta, weights, learningRate) {

return [Link]((row, i) => [Link]((w, j) => w + learningRate *
delta[j] * input[i]));
}

adjustBias(bias, delta, learningRate) {

return [Link]((b, i) => b + learningRate * delta[i]);
}

train(input, expected, learningRate = 0.1) {

[Link](input);
[Link](input, expected, learningRate);
}

predict(input) {
return [Link](input);
}
}

const inputSize = 5;
const hiddenSize = 10;
const outputSize = 2;
const learningRate = 0.1;

const nn = new NeuralNetwork(inputSize, hiddenSize, outputSize);

const trainingData = [
{
inputs: [[Link], [Link], [Link],
[Link], [Link],
proheal,players,buildingData,[Link]],
expected: [prohealLength > 0 ? 1 : 0, [Link] < 100 ? 1 :
0]
}
];

trainAI(trainingData);

if ([Link] <= 0) {
const deathData = [Link]([Link]('deathData') ||
'[]');
[Link]({ inputs, shameCount });
[Link]('deathData', [Link](deathData));
} else {
}

var tmpTime = [Link]();

for(var i = 0; i < [Link]; ++i){
players[i].forcePos = !players[i].visible;
players[i].visible = false;
}

for(var i = 0; i < [Link];){

tmpObj = findPlayerBySID(data[i]);
if (tmpObj) {
const lastX = tmpObj.x2, lastY = tmpObj.y2;

[Link] = primaryReload[[Link]];
[Link] = secondaryReload[[Link]];

tmpObj.t1 = (tmpObj.t2===undefined)?tmpTime:tmpObj.t2;
tmpObj.t2 = tmpTime;

tmpObj.x1 = tmpObj.x;
tmpObj.y1 = tmpObj.y;

tmpObj.x2 = data[i + 1];

tmpObj.y2 = data[i + 2];

[Link] = tmpObj.x2 * 2 - lastX;

[Link] = tmpObj.y2 * 2 - lastY;

tmpObj.d1 = (tmpObj.d2===undefined)?data[i + 3]:tmpObj.d2;

tmpObj.d2 = data[i + 3];

[Link] = 0;

[Link] = data[i + 4];

[Link] = data[i + 5];
[Link] = data[i + 6];

[Link] = data[i + 7];

[Link] = data[i + 8];
[Link] = data[i + 9];
[Link] = data[i + 10];

[Link] = data[i + 11];

[Link] = data[i + 12];

if([Link]){
primaryReload[[Link]] = 1;
secondaryReload[[Link]] = 1;
turretReload[[Link]] = 1;
}

[Link] = true;
doWeaponStuff(tmpObj);
}

i += 13;
}
const promise = new Promise(function(resolve, reject){
promiseResolve = resolve;

setTimeout(function(){
if(!promiseResolve) return;
promiseResolve(false);
}, 1);
});

[Link](function(newObject){
if(tickPromiseResolve){
tickPromiseResolve(true);
}

promiseResolve = null;

visibleObjects = [Link](object =>

[Link](object.x, object.y, myPlayer.x2, myPlayer.y2) < 1000);

// CHECK COLLISION
for(const object of visibleObjects){
if([Link] > 0 || [Link]) continue;

const tmpLen = 35 + [Link]();

if(([Link]([Link], [Link], object.x,
object.y) - tmpLen) < 0){
const tmpDir = Math.atan2([Link]-object.y,
[Link]-object.x);

[Link] = object.x + (tmpLen * [Link](tmpDir));

[Link] = object.y + (tmpLen * [Link](tmpDir));
}
}

updatePredictEnemyTraps();

for(let i in players){
if(players[i].visible && players[i] != myPlayer &&
(players[i].team == null || players[i].team != [Link])){
[Link](players[i]);
}
}

nearestEnemy = [Link]((a, b) =>

[Link](myPlayer.x2, myPlayer.y2, a.x2, a.y2) -
[Link](myPlayer.x2, myPlayer.y2, b.x2, b.y2))[0];

nearestEnemiesCount = 0;
for(let enemy of enemiesNear) {
if([Link](myPlayer.x2, myPlayer.y2, enemy.x2,
enemy.y2) <= 300){
nearestEnemiesCount++;
}

let trap = [Link](object => [Link] == 15 &&

[Link](enemy.x2, enemy.y2, object.x, object.y) < 50 && ([Link]
== [Link] || isAlly([Link])))[0];
if(trap && [Link]){
[Link] = false;
}
}

if([Link] > 0){

for(let shoot of objectShoots){
const {objects, projectile} = shoot;
checkBuildingDamage(projectile, objects);
}

objectShoots = [];
}

if([Link] > 0){

for(let objectHit of objectHits){
changeObjectHealth([Link], [Link],
[Link]);
}

objectHits = [];
}

// ENEMY SPIKES
enemySpikes = [Link](object => [Link] > 5 &&
[Link] < 10 && [Link] != [Link] && !isAlly([Link]));
let nearestSpike = [Link]((a, b) =>
[Link](myPlayer.x2, myPlayer.y2, a.x, a.y) -
[Link](myPlayer.x2, myPlayer.y2, b.x, b.y))[0];

// NEAREST TRAP
const lastNearestTrap = nearestTrap;
if(nearestTrap && [Link]((sid) => [Link] ==
sid)){
trapBreaked = true;
trapBreakedTick = tick;
}

if(trapBreaked && (tick - trapBreakedTick) > 1){

trapBreaked = false;
}

nearestTrap = [Link](object => [Link] == 15 &&

[Link](myPlayer.x2, myPlayer.y2, object.x, object.y) <= 50 &&
([Link] != [Link] && !isAlly([Link])))[0];

// AUTO BREAK
breakObject = null;
if(nearestTrap){
if([Link]){
[Link] = false;
}

if(nearestSpike){
if(spikeDmgCount > 0){
if(nearestEnemy && [Link](nearestEnemy.x2,
nearestEnemy.y2, nearestTrap.x, nearestTrap.y) < [Link](nearestEnemy.x2,
nearestEnemy.y2, nearestSpike.x, nearestSpike.y)){
breakObject = nearestTrap;
if([Link][1] == 10 &&
[Link](myPlayer.x2, myPlayer.y2, nearestSpike.x, nearestSpike.y) <=
([Link][[Link][1]].range + [Link])){
breakObject = nearestSpike;
} else {
if([Link][[Link][0]].speed <
400 && [Link](myPlayer.x2, myPlayer.y2, nearestSpike.x, nearestSpike.y)
<= ([Link][[Link][0]].range + [Link])){
breakObject = nearestSpike;
}
}
} else {
breakObject = nearestTrap;
}
} else {
breakObject = nearestTrap;
if([Link][1] == 10 &&
[Link](myPlayer.x2, myPlayer.y2, nearestSpike.x, nearestSpike.y) <=
([Link][[Link][1]].range + [Link])){
breakObject = nearestSpike;
} else {
if([Link][[Link][0]].speed < 400
&& [Link](myPlayer.x2, myPlayer.y2, nearestSpike.x, nearestSpike.y) <=
([Link][[Link][0]].range + [Link])){
breakObject = nearestSpike;
}
}
}
} else {
breakObject = nearestTrap;
}
} else {
if(nearestSpike){
if([Link][1] == 10 &&
[Link](myPlayer.x2, myPlayer.y2, nearestSpike.x, nearestSpike.y) <=
([Link][[Link][1]].range + [Link])){
breakObject = nearestSpike;
}
}
}

if(breakObject){
autoBreakAngle = Math.atan2(breakObject.y-myPlayer.y2,
breakObject.x-myPlayer.x2);
autoBreak = true;
} else {
if(autoBreak){
autoReload = true;
autoBreak = false;
}
}
if(soldierAnti){
soldierAnti = false;
}

if([Link] > 0){

for(let i in hits){
let {player, isObjectHit, weapon} = hits[i];

if(weapon < 9){

if([Link] == 20 &&
[Link][weapon].speed > 300){
primaryReload[[Link]] = .22;
} else {
primaryReload[[Link]] = 0;
}
} else {
if([Link] == 20){
secondaryReload[[Link]] = .22;
} else {
secondaryReload[[Link]] = 0;
}
}

if([Link] == [Link]){
// FIX GATHER GLITCH
if(checkGather){
if(!autogathering){
autogathering = true;
}

checkGather = false;
}
} else {
if(!isAlly([Link])){
distributionDamages({type: "hit", weapon: weapon,
player: player});
}
}
}

hits = [];
}

if([Link] > 0){

for(let i in shoots){
let {x, y, range, speed, projectile} = shoots[i];

[Link] = null;
[Link] = null;

if([Link] == 1.5){
[Link] = "turret";

let dist = 35;

for(let player of players){
if([Link] && dist >
[Link](player.x2, player.y2, projectile.x, projectile.y)){
[Link] = player;
dist = [Link](player.x2, player.y2,
projectile.x, projectile.y);
}
}

if([Link] != null){
projectileHandle(projectile);
turretReload[[Link]] = 0;
} else {
let dist = 43;
for(let object of visibleObjects){
if(dist > [Link](object.x, object.y,
projectile.x, projectile.y)){
[Link] = object;
dist = [Link](object.x,
object.y, projectile.x, projectile.y);
}
}
}
} else {
projectile.x2 = x - [Link]([Link]) * 70;
projectile.y2 = y - [Link]([Link]) * 70;

for(let i in [Link]){
if([Link][i].range == range &&
[Link][i].speed == speed){
for(let weapon of [Link]){
if([Link] == i){
[Link] = [Link];
}
}
}
}

let dist = 200;

for(let player of players){
if([Link] && [Link](player.x2,
player.y2, projectile.x2, projectile.y2) < dist && [Link][1] ==
[Link]){
[Link] = player;
dist = [Link](player.x2, player.y2,
projectile.x2, projectile.y2);
}
}

if([Link] != null){
if([Link] == 20){
secondaryReload[[Link]] = .22;
} else {
secondaryReload[[Link]] = 0;
}
}
}
}

shoots = [];
}

if([Link] > 0){

for(let i in removeShoots){
let projectile = removeShoots[i];

if([Link]){
if([Link] != myPlayer && !
isAlly([Link])){
distributionDamages({type: "shoot", projectile:
projectile});
}
}
}

removeShoots = [];
}

// GET SPIKE DAMAGES

distributionDamages({type: "spikes"});
if([Link] > 0){
spikeDmgCount++;

for(let i in spikeDamages){
spikeDmg++;
}
} else {
spikeDmgCount = 0;
}

// DAMAGE BY POISON
for(let damage of damages){
if(damage == 5 || damage == (5 * .75)){
damageByPoisonTick = tick;
}
}

// PREDICT MOVE
predictMove = [];
for(let i in keys){
if(!keys[i]) continue;

if(moveVectors[i]){
[Link](moveVectors[i]);
}
}

predictMoveAngle = null;
if([Link] > 0){
let moveX = 0;
let moveY = 0;

for(let vector of predictMove){

moveX += vector[0];
moveY += vector[1];
}

if(moveX != 0 || moveY != 0){

predictMoveAngle = Math.atan2(moveY, moveX);
}
}
// AUTO PUSH
autoPush = false;
autoPushAngle = null;
if(nearestEnemy && !nearestTrap){
let trap = [Link](object => [Link] == 15 &&
[Link](nearestEnemy.x2, nearestEnemy.y2, object.x, object.y) < 50 &&
([Link] == [Link] || isAlly([Link])))[0];
if(trap){
let spikes = [Link](object => [Link] > 5
&& [Link] < 10 && [Link](trap.x, trap.y, object.x, object.y) < (35 /
2 + [Link] + [Link]) && ([Link] == [Link] ||
isAlly([Link])));
let nearestSpike = [Link]((a, b) =>
[Link](nearestEnemy.x2, nearestEnemy.y2, a.x, a.y) -
[Link](nearestEnemy.x2, nearestEnemy.y2, b.x, b.y))[0];

if(nearestSpike && !isSpikeCollisionEnemy(nearestSpike)){

let posX = nearestSpike.x + [Link] *
[Link](Math.atan2(trap.y-nearestSpike.y, trap.x-nearestSpike.x));
let posY = nearestSpike.y + [Link] *
[Link](Math.atan2(trap.y-nearestSpike.y, trap.x-nearestSpike.x));

pushPositions = {
x: posX + ([Link](posX, posY,
nearestEnemy.x2, nearestEnemy.y2) + 35) * [Link](Math.atan2(nearestEnemy.y2-posY,
nearestEnemy.x2-posX)),
y: posY + ([Link](posX, posY,
nearestEnemy.x2, nearestEnemy.y2) + 35) * [Link](Math.atan2(nearestEnemy.y2-posY,
nearestEnemy.x2-posX)),
x2: posX,
y2: posY
};

if(canAutoPush()){
autoPush = true;
autoPushAngle = Math.atan2(pushPositions.y-
myPlayer.y2, pushPositions.x-myPlayer.x2);
}
}
}
}

if(autoPush){
predictMoveAngle = autoPushAngle;
}

// ANTI SPIKE TICK

antiSpikeTick = false;
if(nearestEnemy){
for(let i = 0;i < 36;i++){
let angle = [Link](i * (360 / 36));
let id = 9;

let config = {
x: [Link] + (35 + [Link][id].scale +
([Link][id].placeOffset || 0)) * [Link](angle),
y: [Link] + (35 + [Link][id].scale +
([Link][id].placeOffset || 0)) * [Link](angle),
scale: [Link][id].scale
};

if([Link](config.x, config.y,
[Link], 0.6, id, false, nearestEnemy, visibleObjects)){
if([Link](myPlayer.x2, myPlayer.y2,
config.x, config.y) <= (35 + [Link])){
antiSpikeTick = true;
}

if([Link]([Link], [Link],
config.x, config.y) <= (35 + [Link])){
antiSpikeTick = true;
}
}
}
}
/* function autoVelocityTick(dt, angle) {
try {
let minimumOTRange = (1.5 * (1000/9)) + 35;
let maximumOTRange = (1.5 * (1000/9)) + 80;
var spdMult = (([Link]>=0)?0.5:1) *
([Link][[Link]].spdMult||1) *
([Link]?([Link]||1):1) *
([Link]?([Link]||1):1) * (myPlayer.y<=[Link]?

(([Link]&&[Link])?1:[Link]):1) * [Link];
if ([Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) > 201.66666666666665
&& [Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) < 246.66666666666665) {
if (!nearestTrap && ([Link] != 6)) {
elotickers();
}
}
} catch (e) {
[Link](e);
}
} */
function grrniggergrr() {
if (primaryReload[[Link]] == 1 &&
turretReload[[Link]] == 1) {
hat(53, 0);
keyCodeWeapon = [Link][0];
selectWeapon(keyCodeWeapon);
setTimeout(() => {
autoaim = true;
keyCodeWeapon = [Link][0];
selectWeapon(keyCodeWeapon);
hat(7, 0);
[Link]("F", 1);
setTimeout(() => {
autoaim = false;
[Link]("F", null, 0);
}, 200);
}, 93);
}
}
if (autoVelocityTickToggled) {
if (nearestEnemy && myPlayer && [Link]) {
let minimumOTRange = (1.5 * (1000/9)) + 35;
let maximumOTRange = (1.5 * (1000/9)) + 80;
/* simple velocity caculation */
let distance = [Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2);
if (![Link] && !nearestTrap && (distance <
maximumOTRange && distance > minimumOTRange) && [Link] != 6) {
grrniggergrr();
}
}
}
healing = false;
if([Link]){
// PREDICT WEAPON
predictWeapon = getPredictWeapon();

// RESET PREDICT DAMAGES

resetPredictDamages();

// PREDICT POISON DAMAGE

if((tick - damageByPoisonTick) % 9 == 8){
[Link] = 5;
}

// PREDICT SPIKE DAMAGE

(function(){
let damage = 0;
if([Link] > 0){
for(let i of spikeDamages){
if([20 * .75, 30 * .75, 35 * .75, 45
* .75].includes(i)){
damage += (i / .75);
} else {
damage += i;
}
}
}

if([Link] < damage){

[Link] = damage;
}
})();

(function(){
if(trapBreaked){
if([Link] < 45){
[Link] = 45;
}
}
})();

(function(){
let damage = 0;
if(predictMoveAngle != null && !nearestTrap){
let posX = myPlayer.x2 + 50 *
[Link](predictMoveAngle);
let posY = myPlayer.y2 + 50 *
[Link](predictMoveAngle);
for(let object of [Link]((object) =>
[Link](posX, posY, object.x, object.y) < (35 + [Link]))){
damage += [Link][[Link]].dmg;
}
}

if([Link] < damage){

[Link] = damage;
}
})();

(function(){
let damage = 0;
for(let object of [Link]((object) =>
[Link]([Link], [Link], object.x, object.y) < (35 +
[Link]))){
damage += [Link][[Link]].dmg;
}

if([Link] < damage){

[Link] = damage;
}
})();

antiVelocitySpikeSync = false;

// GET TURRET DAMAGES

if([Link] > 0){
for(let i in damagesByShoots){
let {damage, projectile} = damagesByShoots[i];

if([Link] != "turret") continue;

[Link]({damage: damage, projectile:
projectile});
}
}

// HIT DAMAGES
if([Link] > 0){
for(let i in damagesByHits){
let {damage, player, weapon} = damagesByHits[i];

if(weapon < 8){

antiInstaFc({type: "normal", player: player});
} else {
if(weapon == 10){
antiInstaFc({type: "reverse", player: player});
}
}
}

damagesByHits = [];
}

// SHOOT DAMAGES
if([Link] > 0){
for(let i in damagesByShoots){
let {damage, projectile} = damagesByShoots[i];
if([Link] == "turret") continue;
antiInstaFc({type: "reverse", player:
[Link]});
}

damagesByShoots = [];
}

// PREDICT VELOCITY SPIKE SYNC

if(nearestEnemy && [Link] > 0){
if(primaryReload[[Link]] == 1){
let primaryWeapon = [Link][0] ?
[Link][0] : null;
let primaryVariant = 0;

if(primaryWeapon != null){
primaryVariant =
[Link][primaryWeapon];
} else {
primaryVariant = 3;
primaryWeapon = 5;
}

if(nearestTrap){
if([Link]([Link], [Link],
[Link], [Link]) <= (35 * 1.8 +
[Link][primaryWeapon].range)){
if(spikeDmgCount < 2 ||
[Link] != primaryReload[[Link]] ||
[Link](myPlayer.x2, myPlayer.y2, nearestEnemy.x2, nearestEnemy.y2) > (35
* 1.8 + [Link][primaryWeapon].range)){
if([Link] == 0){
[Link] +=
[Link][primaryWeapon].dmg * 1.5 * [Link][primaryVariant].val;
}

if(100 <= getPredictDamage()){

antiVelocitySpikeSync = true;
}
}
}
} else {
if([Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) <= 300){
if([Link] == 0){
[Link] +=
[Link][primaryWeapon].dmg * 1.5 * [Link][primaryVariant].val;
}

if(100 <= getPredictDamage()){

antiVelocitySpikeSync = true;
}
}
}
}

// PREDICT KNOCK BACK SPIKE SYNC

if(nearestEnemy && !nearestTrap){
let damage = 0;

if(primaryReload[[Link]] == 1){
let primaryWeapon = [Link][0] ?
[Link][0] : null;
let primaryVariant = 0;

if(primaryWeapon != null){
primaryVariant =
[Link][primaryWeapon];
} else {
primaryVariant = 3;
primaryWeapon = 5;
}

if([Link](myPlayer.x2, myPlayer.y2,
nearestEnemy.x2, nearestEnemy.y2) <= (35 * 1.8 +
[Link][primaryWeapon].range)){
if([Link] == 0){
[Link] +=
[Link][primaryWeapon].dmg * 1.5 * [Link][primaryVariant].val;
}

let knock = 111 * (.3 +

([Link][primaryWeapon].knock || 0));

let posX = myPlayer.x2 + knock *

[Link](Math.atan2(myPlayer.y2-nearestEnemy.y2, myPlayer.x2-nearestEnemy.x2));
let posY = myPlayer.y2 + knock *
[Link](Math.atan2(myPlayer.y2-nearestEnemy.y2, myPlayer.x2-nearestEnemy.x2));

for(let object of [Link]((object) =>

[Link](posX, posY, object.x, object.y) <= (35 + [Link]))){
damage += [Link][[Link]].dmg;
}

if([Link] < damage){

[Link] = damage;
}

if(100 <= getPredictDamage()){

antiVelocitySpikeSync = true;
}
}
}
}

// TURRET DAMAGES
if([Link] > 0){
for(let i in damagesByTurrets){
let {damage, projectile} = damagesByTurrets[i];

if([Link] != null && !

antiReverse[[Link]]){
healing = true;
}
}

damagesByTurrets = [];
}

// SPIKE DAMAGES
if([Link] > 0){
if(spikeDmgCount < 2 && (!nearestTrap || (nearestTrap && !
lastNearestTrap))){
healing = true;
}

spikeDamages = [];
}

damages = [];

antiReverse = [];
antiInsta = [];

if(predictMoveAngle != lastMoveAngle){
[Link]("9", predictMoveAngle);
lastMoveAngle = predictMoveAngle;
}

if(nearestEnemy && settings.x18ksync &&

primaryReload[[Link]] == 1 && !autoaim){
let myPlayerDamage = 0;
if([Link]([Link], [Link],
[Link], [Link]) <= (35 * 1.8 +
[Link][[Link][0]].range)){
myPlayerDamage +=
[Link][[Link][0]].dmg * 1.5 *
[Link][[Link][[Link][0]]].val;
}

for(let player of [Link]((player) => [Link] !=

[Link] && isAlly([Link]))){
const nearestEnemyAlly = [Link]((a, b) =>
[Link](player.x2, player.y2, a.x2, a.y2) - [Link](player.x2,
player.y2, b.x2, b.y2))[0];
if([Link] != [Link]) continue;

let allyDamage = 0;
if([Link]([Link], [Link],
[Link], [Link]) <= (35 * 1.8 +
[Link][[Link][0]].range)
&& primaryReload[[Link]] == 1){
allyDamage += [Link][[Link][0]].dmg
* 1.5 * [Link][[Link][[Link][0]]].val;
}
if(((myPlayerDamage + allyDamage) * .75) > 100){
instaKill = ["primary", "stop"];
break;
}
}
}

if(canVelocitySpikeTick()){
instaKill = ["primary", "stop"];
}

// INTSA KILL FUNCTION

if([Link] > 0){
if(instaKill[0] == "secondary"){
autoaim = true;

[Link] = false;
[Link] = true;

predictWeapon = [Link][1];

if(!isBadTail()){
[Link]();
}
} else if(instaKill[0] == "primary"){
autoaim = true;

[Link] = true;
[Link] = false;

predictWeapon = [Link][0];

if(!isBadTail()){
[Link]();
}
} else if(instaKill[0] == "stop"){
[Link] = false;
[Link] = false;

autoaim = false;

autoReload = true;
[Link]();
}
}

antiPush = isNearestEnemyPushPlayer();
if(antiPush){
predictWeapon = [Link][0];
}

// HEAL
let damageHealed = false;
if(((healing && [Link] < 7) || (tick - damageTick)
> 0) && [Link] < 100){
heal(100 - [Link]);
damageHealed = true;
}

// PLAYER WEAPON
if([Link] != predictWeapon || [Link]
>= 0){
selectWeapon(predictWeapon);
}

// FIX GATHER GLITCH

if(checkGather){
if(autogathering){
autogathering = false;
}

checkGather = false;
}

// PLAYER AUTO GATHER

if(needAutoGather()){
if(!autogathering){
sendAutoGather();
}
} else {
if(autogathering){
sendAutoGather();
}
}

// CHECK GATHER
if([Link] < 0){
if([Link] < 9){
if(primaryReload[[Link]] == 1){
checkGather = true;
}
} else {
if(secondaryReload[[Link]] == 1){
checkGather = true;
}
}
}

// PLAYER HATS & ACCESSORIES

hatFc();

// AUTO PLACER
getPredictObjects();
for(let object of predictObjects){
if([Link]) continue;
place([Link], [Link]);
addEnemyTrap([Link], [Link]);
}

// PLAYER DIRECTION
let angle = getAttackDir();
if([Link] > 0 || damageHealed){
[Link]("D", angle);
} else {
if([Link](myPlayer.d2 - angle) > 0.3){
[Link]("D", angle);
}
}
} else {
predictObjects = [];

if([Link] > 0){

addChatLog(`Mod: Predict Damages before death $
{[Link](predictDamage)}`, "#ffffff");
addChatLog(`Mod: Damages before death $
{[Link](deathDamages)}`, "#ffffff");

deathDamages = [];
}
}

for(let player of players){

if([Link] <= 0) continue;
[Link] = 0;
}
});
// PRE PLACER
setTimeout(function(){
for(let object of predictObjects){
if(![Link]) continue;

place([Link], [Link]);
[Link]("D", getAttackDir());
}
}, 1);

setTimeout(function(){
for(let object of predictObjects){
if(![Link]) continue;
place([Link], [Link]);
[Link]("D", getAttackDir());
}
}, 111 - [Link]);

setTimeout(function(){
if(spamPrePlacer){
for(let object of predictObjects){
if(![Link]) continue;
place([Link], [Link]);
[Link]("D", getAttackDir());
}
}
}, 111 - minPingTime);
// AUTO FOLLOW
autoFollow();
}

let tickInterval;
let tickPromiseResolve;

function needAutoGather(){
return (((ePress || autoaim) && !isBadTail()) || autoBreak || antiPush)
&& !antiVelocitySpikeSync && !soldierAnti;
}

function isBadTail(){
if(autoaim){
if([Link] == 11){
return true;
}
} else {
if(predictWeapon < 8 && [Link] == 11){
return true;
}
}
}

function isPlayerCanInsta(){
if(!nearestEnemy) return;

let damage = 0;
if(primaryReload[[Link]] == 1){
let primaryWeapon = [Link][0] ?
[Link][0] : null;
let primaryVariant = 0;

if(primaryWeapon != null){
primaryVariant = [Link][primaryWeapon];
} else {
primaryVariant = 3;
primaryWeapon = 5;
}

damage += [Link][primaryWeapon].dmg * 1.5 *

[Link][primaryVariant].val;
}

if(secondaryReload[[Link]] == 1){
let secondaryWeapon = [Link][1] ?
[Link][1] : 15;
if([Link][secondaryWeapon].projectile != undefined){
damage +=
[Link][[Link][secondaryWeapon].projectile].dmg;
} else {
damage += [Link][secondaryWeapon].dmg *
[Link][[Link][secondaryWeapon]].val;
}
}

if(turretReload[[Link]] == 1){
damage += 25;
}
if(damage >= 100) return true;
}

function hatFc(){
// HAT
let currentHat = 0;
if(isBoughtHat(6, 0)){
currentHat = 6;
}

if(isBoughtHat(12, 0)){
currentHat = 12;
}

if(myPlayer.y < 2400 && isBoughtHat(15, 0)){

currentHat = 15;
}

if((myPlayer.y > 6838 && myPlayer.y < 7562) && isBoughtHat(31, 0)){
currentHat = 31;
}

if(autogathering && isBoughtHat(6, 0)){

currentHat = 6;
}

if(isBoughtHat(7, 0)){
if([Link] > 0 && [Link] != 45 &&
[Link] > (5 + getPredictDamage()) && (tick - damageByPoisonTick) >= 8){
currentHat = 7;
}
}

if(nearestEnemy && [Link](myPlayer.x2, myPlayer.y2,

nearestEnemy.x2, nearestEnemy.y2) <= 300 && isBoughtHat(6, 0)){
currentHat = 6;
}

if(isBoughtHat(7, 0)){
if([Link] > 0 && [Link] != 45 &&
[Link] > (5 + getPredictDamage()) && (tick - damageByPoisonTick) >= 8
&& (!nearestEnemy || !isPlayerCanInsta())){
currentHat = 7;
}
}

if((antiSpikeTick || (nearestTrap && spikeDmgCount > 0)) &&

isBoughtHat(6, 0)){
currentHat = 6;
}

if(autogathering){
if(predictWeapon < 9){
if(primaryReload[[Link]] == 1){
if(autoBreak){
if(antiPush){
if(isBoughtHat(7, 0)){
currentHat = 7;
}
} else {
if(isBoughtHat(40, 0)){
currentHat = 40;
}
}
} else {
if(predictWeapon < 8 && nearestEnemy &&
[Link]([Link], [Link], [Link],
[Link]) <= (35 * 1.8 + [Link][predictWeapon].range)){
if(isBoughtHat(7, 0)){
currentHat = 7;
}
} else {
if(isBoughtHat(40, 0)){
currentHat = 40;
}
}
}
}
} else if(predictWeapon != 11){
if(secondaryReload[[Link]] == 1){
if(predictWeapon == 10){
if(isBoughtHat(40, 0)){
currentHat = 40;
}
} else {
if(isBoughtHat(20, 0)){
currentHat = 20;
}
}
}
}
}

// ACC
let currentAcc = 0;
if(isBoughtHat(11, 1)){
currentAcc = 11;
}

if (nearestEnemy) {
if (isBoughtHat(19, 1)) {
currentAcc = 19;
}
}

if([Link][0] == 8 && isBoughtHat(11, 1)){

currentAcc = 11;
}

// HAT & ACC

if([Link] && isBoughtHat(7, 0)){
currentHat = 7;
}

// EQUIP
hat(currentHat);
acc(currentAcc);
}

// FIND OBJECTS BY ID/SID:

let pings = [];

let minPingTime = Infinity;
let maxPingTime = 0;
let averagePing = 0;
let isFirstPing = true;

// PING:
var lastPing = -1;
function pingSocketResponse() {
var pingTime = [Link]() - lastPing;
[Link] = pingTime;

if(!isFirstPing){
if([Link] > 200){
pings = [];
}

[Link](pingTime);

averagePing = 0;
for(let ping of pings){
averagePing += ping;
}

averagePing = averagePing / [Link];

if(pingTime < minPingTime){
minPingTime = pingTime;
}

if(pingTime > maxPingTime){

maxPingTime = pingTime;
}
} else {
isFirstPing = false;
}

[Link] = `Ping: ${[Link]} ms | Min: $

{minPingTime} ms | Max: ${maxPingTime} ms | Average: ${averagePing} ms`;
}
function pingSocket() {
lastPing = [Link]();
[Link]("0");
}

// SERVER SHUTDOWN NOTICE:

function serverShutdownNotice(countdown) {
if (countdown < 0) return;

var minutes = [Link](countdown / 60);

var seconds = countdown % 60;
seconds = ("0" + seconds).slice(-2);

[Link] = "Server restarting in " + minutes + ":" +

seconds;
[Link] = false;
}

// UPDATE & ANIMATE:

function doUpdate() {
now = [Link]();
delta = now - lastUpdate;
lastUpdate = now;
updateGame();
requestAnimationFrame(doUpdate);
}

// START GAME:
function startGame() {
bindEvents();
loadIcons();
[Link] = "none";
[Link] = "block";
[Link] = getSavedVal("moo_name")||"";
prepareUI();
}
prepareMenuBackground();
doUpdate();

// OPEN LINK:
function openLink(link) {
[Link](link, "_blank")
}

// EXPORT VALUES:
[Link] = openLink;
[Link] = aJoinReq;
[Link] = follmoo;
[Link] = kickFromClan;
[Link] = sendJoin;
[Link] = leaveAlliance;
[Link] = createAlliance;
[Link] = storeBuy;
[Link] = storeEquip;
[Link] = showItemInfo;
[Link] = selectSkinColor;
[Link] = changeStoreIndex;
[Link] = config;

/***/ }),

/***/ "./src/js/[Link]":
/*!**************************!*\
!*** ./src/js/[Link] ***!
\**************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(process) {

// RENDER:
[Link] = 1920;
[Link] = 1080;

// SERVER:
[Link] = 9;
[Link] = (1000 / [Link]);
[Link] = Infinity; // (process &&
[Link]("--largeserver") != -1) ? 80 : 50;
[Link] = Infinity; // [Link]
+ 10;
[Link] = 6;
[Link] = 3000;

// COLLISIONS:
[Link] = 10;
// CLIENT:
[Link] = 5;

// UI:
[Link] = 50;
[Link] = 4.5;
[Link] = 15;
[Link] = 0.9;
[Link] = 0;
[Link] = 60;
[Link] = 35;

// CHAT:
[Link] = 3000;
[Link] = 500;

// SANDBOX:
[Link] = process && [Link].VULTR_SCHEME ===
"mm_exp";
[Link] = [Link] ==
"[Link]";

// PLAYER:
[Link] = 100;
[Link] = [Link]/2.6;
[Link] = 10;
[Link] = 0.25;
[Link] = [Link] / 2;
[Link] = 35;
[Link] = 0.0016;
[Link] = 0.993;
[Link] = 34;

// CUSTOMIZATION:
[Link] = ["#bf8f54", "#cbb091", "#896c4b",
"#fadadc", "#ececec", "#c37373",
"#4c4c4c", "#ecaff7", "#738cc3",
"#8bc373", "#91b2db"];

// ANIMALS:
[Link] = 7;
[Link] = 0.06;
[Link] = ["Sid", "Steph", "Bmoe", "Romn",
"Jononthecool", "Fiona", "Vince", "Nathan", "Nick", "Flappy", "Ronald", "Otis",
"Pepe", "Mc Donald", "Theo", "Fabz", "Oliver", "Jeff", "Jimmy", "Helena", "Reaper",
"Ben", "Alan", "Naomi", "XYZ", "Clever",
"Jeremy", "Mike", "Destined", "Stallion", "Allison", "Meaty", "Sophia", "Vaja",
"Joey", "Pendy", "Murdoch", "Theo", "Jared", "July", "Sonia", "Mel", "Dexter",
"Quinn", "Milky"];

// WEAPONS:
[Link] = [Link]/3;
[Link] = [{
id: 0,
src: "",
xp: 0,
val: 1
}, {
id: 1,
src: "_g",
xp: 3000,
val: 1.1
}, {
id: 2,
src: "_d",
xp: 7000,
val: 1.18
}, {
id: 3,
src: "_r",
poison: true,
xp: 12000,
val: 1.18
}];
[Link] = function(player) {
var tmpXP = [Link][[Link]]||0;
for (var i = [Link] - 1; i >= 0; --i)
{
if (tmpXP >= [Link][i].xp)
return [Link][i];
}
};

// NATURE:
[Link] = ["wood", "food", "stone", "points"];
[Link] = 7;
[Link] = 9;
[Link] = 3;
[Link] = 32;
[Link] = 7;
[Link] = 724;
[Link] = 114;
[Link] = 0.0011;
[Link] = 0.0001;
[Link] = 1.3;
[Link] = [150, 160, 165, 175];
[Link] = [80, 85, 95];
[Link] = [80, 85, 90];

// BIOME DATA:
[Link] = 2400;
[Link] = 0.75;

// DATA:
[Link] = 15;

// MAP:
[Link] = 14400;
[Link] = 40;
[Link] = 2200;

/* WEBPACK VAR INJECTION */}.call(this,

__webpack_require__(/*! ./../../node_modules/process/[Link] */
"./node_modules/process/[Link]")))

/***/ }),

/***/ "./src/js/data/[Link]":
/*!***************************!*\
!*** ./src/js/data/[Link] ***!
\***************************/
/*! no static exports found */
/***/ (function(module, exports) {

var PI2 = [Link] * 2;

[Link] = function(sid, objectManager, players, items, UTILS,
config, scoreCallback, server) {
[Link] = sid;
[Link] = true;
[Link] = [Link](0, [Link]-1);

// INIT:
[Link] = function(x, y, dir, index, data) {
this.x = x;
this.y = y;
[Link] = [Link]?x:null;
[Link] = [Link]?y:null;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = dir;
[Link] = 0;
[Link] = index;
[Link] = [Link];
if ([Link]) [Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = 0;
[Link] = 1000;
[Link] = 0;
[Link] = 0;
[Link] = true;
[Link] = true;
[Link] = null;
[Link] = null;
[Link] = {};
};

// UPDATE:
var timerCount = 0;
[Link] = function(delta) {
if ([Link]) {

// SPAWN DELAY:
if ([Link]) {
[Link] -= delta;
if ([Link] <= 0) {
[Link] = 0;
this.x = [Link]||[Link](0,
[Link]);
this.y = [Link]||[Link](0,
[Link]);
}
return;
}

// REGENS AND AUTO:

timerCount -= delta;
if (timerCount <= 0) {
if ([Link]) {
[Link](-[Link],
[Link]);
[Link] -= 1;
if ([Link] <= 0)
[Link] = 0;
}
timerCount = 1000;
}

// BEHAVIOUR:
var charging = false;
var slowMlt = 1;
if (![Link] && ![Link] && this.y >=
([Link] / 2) - ([Link] / 2) &&
this.y <= ([Link] / 2) + ([Link] / 2))
{
slowMlt = 0.33;
[Link] += [Link] * delta;
}
if ([Link]) {
[Link] = 0;
[Link] = 0;
} else if ([Link] > 0) {
[Link] -= delta;
if ([Link] <= 0) {
if ([Link]) {
var tmpPlayer, bestDst, tmpDist;
for (var i = 0; i < [Link]; ++i) {
if (players[i].alive && !(players[i].skin &&
players[i].[Link])) {
tmpDist = [Link](this.x, this.y,
players[i].x, players[i].y);
if (tmpDist <= [Link] && (!
tmpPlayer || tmpDist < bestDst)) {
bestDst = tmpDist;
tmpPlayer = players[i];
}
}
}
if (tmpPlayer) {
[Link] = tmpPlayer;
[Link] = [Link](8000, 12000);
} else {
[Link] = [Link](1000, 2000);
[Link] = [Link](-[Link],
[Link]);
}
} else {
[Link] = [Link](4000, 10000);
[Link] = [Link](-[Link],
[Link]);
}
}
} else if ([Link] > 0) {
var tmpSpd = [Link] * slowMlt;
if ([Link] && [Link] && !
([Link] && ![Link])) {
[Link] = [Link](this.x, this.y,
[Link].x, [Link].y);
tmpSpd *= 1.42;
} else if ([Link] && [Link]) {
[Link] =
[Link]([Link].x, [Link].y, this.x, this.y);
tmpSpd *= 1.75;
charging = true;
} if ([Link]) {
tmpSpd *= 0.3;
}
if ([Link] != [Link]) {
[Link] %= PI2;
var netAngle = ([Link] - [Link] + PI2) % PI2;
var amnt = [Link]([Link](netAngle - PI2), netAngle,
[Link] * delta);
var sign = (netAngle - [Link])>=0?1:-1;
[Link] += sign * amnt + PI2;
}
[Link] %= PI2;
[Link] += (tmpSpd * delta) * [Link]([Link]);
[Link] += (tmpSpd * delta) * [Link]([Link]);
[Link] -= delta;
if ([Link] <= 0) {
[Link] = null;
[Link] = null;
[Link] = [Link]?1500:[Link](1500,
6000);
}
}

// OBJECT COLL:
[Link] = 0;
[Link] = false;
var tmpList;
var tmpSpeed = [Link](0, 0, [Link] * delta,
[Link] * delta);
var depth = [Link](4, [Link](1, [Link](tmpSpeed /
40)));
var tMlt = 1 / depth;
for (var i = 0; i < depth; ++i) {
if ([Link])
this.x += ([Link] * delta) * tMlt;
if ([Link])
this.y += ([Link] * delta) * tMlt;
tmpList = [Link](this.x, this.y,
[Link]);
for (var x = 0; x < [Link]; ++x) {
for (var y = 0; y < tmpList[x].length; ++y) {
if (tmpList[x][y].active)
[Link](this, tmpList[x]
[y], tMlt);
}
}
}

// HITTING:
var hitting = false;
if ([Link] > 0) {
[Link] -= delta;
if ([Link] <= 0) {
hitting = true;
[Link] = 0;
if ([Link] && ![Link](0, 2)) {
[Link] += [Link] * [Link]([Link]);
[Link] += [Link] * [Link]([Link]);
}
var tmpList = [Link](this.x,
this.y, [Link]);
var tmpObj, tmpDst;
for (var t = 0; t < [Link]; ++t) {
for (var x = 0; x < tmpList[t].length; ++x) {
tmpObj = tmpList[t][x];
if ([Link]) {
tmpDst = [Link](this.x, this.y,
tmpObj.x, tmpObj.y);
if (tmpDst < [Link] + [Link])
{
if ([Link](-[Link] * 5))
[Link](tmpObj);
[Link](tmpObj,
[Link](this.x, this.y, tmpObj.x, tmpObj.y));
}
}
}
}
for (var x = 0; x < [Link]; ++x) {
if (players[x].canSee(this)) {
[Link](players[x].id, "J", [Link]);
}
}
}
}

// PLAYER COLLISIONS:
if (charging || hitting) {
var tmpObj, tmpDst, tmpDir;
for (var i = 0; i < [Link]; ++i) {
tmpObj = players[i];
if (tmpObj && [Link]) {
tmpDst = [Link](this.x, this.y,
tmpObj.x, tmpObj.y);
if ([Link]) {
if (![Link] && tmpDst <= [Link] +
[Link]) {
if (hitting) {
tmpDir = [Link](tmpObj.x,
tmpObj.y, this.x, this.y);
[Link](-[Link]);
[Link] += 0.6 * [Link](tmpDir);
[Link] += 0.6 * [Link](tmpDir);
[Link] = null;
[Link] = null;
[Link] = 3000;
[Link] = (![Link](0, 2)?
600:0);
} else [Link] = [Link];
}
} else if (tmpDst <= [Link] + [Link]) {
tmpDir = [Link](tmpObj.x, tmpObj.y,
this.x, this.y);
[Link](-[Link]);
[Link] += 0.55 * [Link](tmpDir);
[Link] += 0.55 * [Link](tmpDir);
}
}
}
}

// DECEL:
if ([Link])
[Link] *= [Link]([Link], delta);
if ([Link])
[Link] *= [Link]([Link], delta);

// MAP BOUNDARIES:
var tmpScale = [Link];
if (this.x - tmpScale < 0) {
this.x = tmpScale;
[Link] = 0;
} else if (this.x + tmpScale > [Link]) {
this.x = [Link] - tmpScale;
[Link] = 0;
} if (this.y - tmpScale < 0) {
this.y = tmpScale;
[Link] = 0;
} else if (this.y + tmpScale > [Link]) {
this.y = [Link] - tmpScale;
[Link] = 0;
}

}
};

// CAN SEE:
[Link] = function(other) {
if (!other) return false;
if ([Link] && [Link] && [Link]
>= [Link]) return false;
var dx = [Link](other.x - this.x) - [Link];
var dy = [Link](other.y - this.y) - [Link];
return dx <= ([Link] / 2) * 1.3 && dy <=
([Link] / 2) * 1.3;
};

// ANIMATION:
[Link] = function() {
[Link] = [Link] = 600;
[Link] = [Link] * 0.8;
tmpRatio = 0;
animIndex = 0;
};

// CHANGE HEALTH:
[Link] = function(val, doer, runFrom) {
if ([Link]) {
[Link] += val;
if (runFrom) {
if ([Link] && ![Link](0, [Link])) {
[Link] = runFrom;
[Link] = 0;
[Link] = 2000;
} else if ([Link] && [Link] &&
[Link]) {
[Link] = runFrom;
[Link] = 0;
[Link] = 8000;
} else if (![Link]) {
[Link] = runFrom;
[Link] = 0;
[Link] = 2000;
}
}
if (val < 0 && [Link] && [Link](0, 1))
[Link] = 500;
if (doer && [Link](this) && val < 0) {
[Link]([Link], "8", [Link](this.x),
[Link](this.y), [Link](-val), 1);
} if ([Link] <= 0) {
if ([Link]) {
[Link] = [Link];
this.x = -1000000;
this.y = -1000000;
} else {
this.x = [Link]||[Link](0,
[Link]);
this.y = [Link]||[Link](0,
[Link]);
}
[Link] = [Link];
[Link] = null;
if (doer) {
scoreCallback(doer, [Link]);
if ([Link]) {
for (var i = 0; i < [Link];) {

[Link]([Link]([Link][i]), [Link][i+1]);
i+=2;
}
}
}
}
}
};

};

/***/ }),

/***/ "./src/js/data/[Link]":
/*!**********************************!*\
!*** ./src/js/data/[Link] ***!
\**********************************/
/*! no static exports found */
/***/ (function(module, exports) {

// AI MANAGER:
[Link] = function(ais, AI, players, items, objectManager, config,
UTILS, scoreCallback, server) {

// AI TYPES:
[Link] = [{
id: 0,
src: "cow_1",
killScore: 150,
health: 500,
weightM: 0.8,
speed: 0.00095,
turnSpeed: 0.001,
scale: 72,
drop: ["food", 50]
}, {
id: 1,
src: "pig_1",
killScore: 200,
health: 800,
weightM: 0.6,
speed: 0.00085,
turnSpeed: 0.001,
scale: 72,
drop: ["food", 80]
}, {
id: 2,
name: "Bull",
src: "bull_2",
hostile: true,
dmg: 20,
killScore: 1000,
health: 1800,
weightM: 0.5,
speed: 0.00094,
turnSpeed: 0.00074,
scale: 78,
viewRange: 800,
chargePlayer: true,
drop: ["food", 100]
}, {
id: 3,
name: "Bully",
src: "bull_1",
hostile: true,
dmg: 20,
killScore: 2000,
health: 2800,
weightM: 0.45,
speed: 0.001,
turnSpeed: 0.0008,
scale: 90,
viewRange: 900,
chargePlayer: true,
drop: ["food", 400]
}, {
id: 4,
name: "Wolf",
src: "wolf_1",
hostile: true,
dmg: 8,
killScore: 500,
health: 300,
weightM: 0.45,
speed: 0.001,
turnSpeed: 0.002,
scale: 84,
viewRange: 800,
chargePlayer: true,
drop: ["food", 200]
}, {
id: 5,
name: "Quack",
src: "chicken_1",
dmg: 8,
killScore: 2000,
noTrap: true,
health: 300,
weightM: 0.2,
speed: 0.0018,
turnSpeed: 0.006,
scale: 70,
drop: ["food", 100]
}, {
id: 6,
name: "MOOSTAFA",
nameScale: 50,
src: "enemy",
hostile: true,
dontRun: true,
fixedSpawn: true,
spawnDelay: 60000,
noTrap: true,
colDmg: 100,
dmg: 40,
killScore: 8000,
health: 18000,
weightM: 0.4,
speed: 0.0007,
turnSpeed: 0.01,
scale: 80,
spriteMlt: 1.8,
leapForce: 0.9,
viewRange: 1000,
hitRange: 210,
hitDelay: 1000,
chargePlayer: true,
drop: ["food", 100]
}, {
id: 7,
name: "Treasure",
hostile: true,
nameScale: 35,
src: "crate_1",
fixedSpawn: true,
spawnDelay: 120000,
colDmg: 200,
killScore: 5000,
health: 20000,
weightM: 0.1,
speed: 0.0,
turnSpeed: 0.0,
scale: 70,
spriteMlt: 1.0
}, {
id: 8,
name: "MOOFIE",
src: "wolf_2",
hostile: true,
fixedSpawn: true,
dontRun: true,
hitScare: 4,
spawnDelay: 30000,
noTrap: true,
nameScale: 35,
dmg: 10,
colDmg: 100,
killScore: 3000,
health: 7000,
weightM: 0.45,
speed: 0.0015,
turnSpeed: 0.002,
scale: 90,
viewRange: 800,
chargePlayer: true,
drop: ["food", 1000]
}, {
id: 9,
name: "??MOOFIE",
src: "wolf_2",
hostile: !0,
fixedSpawn: !0,
dontRun: !0,
hitScare: 50,
spawnDelay: 6e4,
noTrap: !0,
nameScale: 35,
dmg: 12,
colDmg: 100,
killScore: 3e3,
health: 9e3,
weightM: .45,
speed: .0015,
turnSpeed: .0025,
scale: 94,
viewRange: 1440,
chargePlayer: !0,
drop: ["food", 3e3],
minSpawnRange: .85,
maxSpawnRange: .9
}, {
id: 10,
name: "??Wolf",
src: "wolf_1",
hostile: !0,
fixedSpawn: !0,
dontRun: !0,
hitScare: 50,
spawnDelay: 3e4,
dmg: 10,
killScore: 700,
health: 500,
weightM: .45,
speed: .00115,
turnSpeed: .0025,
scale: 88,
viewRange: 1440,
chargePlayer: !0,
drop: ["food", 400],
minSpawnRange: .85,
maxSpawnRange: .9
}, {
id: 11,
name: "??Bully",
src: "bull_1",
hostile: !0,
fixedSpawn: !0,
dontRun: !0,
hitScare: 50,
dmg: 20,
killScore: 5e3,
health: 5e3,
spawnDelay: 1e5,
weightM: .45,
speed: .00115,
turnSpeed: .0025,
scale: 94,
viewRange: 1440,
chargePlayer: !0,
drop: ["food", 800],
minSpawnRange: .85,
maxSpawnRange: .9
}];

// SPAWN AI:
[Link] = function(x, y, dir, index) {
var tmpObj;
for (var i = 0; i < [Link]; ++i) {
if (!ais[i].active) {
tmpObj = ais[i];
break;
}
}
if (!tmpObj) {
tmpObj = new AI([Link], objectManager, players, items,
UTILS, config, scoreCallback, server);
[Link](tmpObj);
}
[Link](x, y, dir, index, [Link][index]);
return tmpObj;
};

};

/***/ }),

/***/ "./src/js/data/[Link]":
/*!***********************************!*\
!*** ./src/js/data/[Link] ***!
\***********************************/
/*! no static exports found */
/***/ (function(module, exports) {

[Link] = function (sid) {

[Link] = sid;

// INIT:
[Link] = function(x, y, dir, scale, type, data, owner) {
data = data||{};
[Link] = {};
[Link] = [];
[Link] = true;
[Link] = [Link];
this.x = x;
this.y = y;
[Link] = dir;
[Link] = 0;
[Link] = 0;
[Link] = scale;
[Link] = type;
[Link] = [Link];
[Link] = owner;
[Link] = [Link];
[Link] = ([Link]!=undefined);
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = 2;
if ([Link] != undefined) {
[Link] = [Link];
} else if ([Link] == 0) {
[Link] = 3;
} else if ([Link] == 2) {
[Link] = 0;
} else if ([Link] == 4) {
[Link] = -1;
}
[Link] = [Link]||1;
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link]||0;
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
};

// GET HIT:
[Link] = function(amount, doer) {
[Link] += amount;
return ([Link] <= 0);
};

// GET SCALE:
[Link] = function(sM, ig) {
sM = sM||1;
return [Link] * (([Link]||[Link]==2||[Link]==3||
[Link]==4)
?1:(0.6*sM)) * (ig?1:[Link]);
};

// VISIBLE TO PLAYER:
[Link] = function(player) {
return !([Link]) || ([Link] && ([Link] ==
player ||
([Link] &&
[Link] == [Link])));
};

// UPDATE:
[Link] = function(delta) {
if ([Link]) {
if ([Link]) {
[Link] *= [Link](0.99, delta);
}
if ([Link]) {
[Link] *= [Link](0.99, delta);
}

/*
if([Link]){
[Link] += [Link] * delta;
}
*/
}
};
};

/***/ }),

/***/ "./src/js/data/[Link]":
/*!******************************!*\
!*** ./src/js/data/[Link] ***!
\******************************/
/*! no static exports found */
/***/ (function(module, exports) {

// ITEM GROUPS:
[Link] = [{
id: 0,
name: "food",
layer: 0
}, {
id: 1,
name: "walls",
place: !0,
limit: 30,
layer: 0
}, {
id: 2,
name: "spikes",
place: !0,
limit: 15,
layer: 0
}, {
id: 3,
name: "mill",
place: !0,
limit: 7,
sandboxLimit: 299,
layer: 1
}, {
id: 4,
name: "mine",
place: !0,
limit: 1,
layer: 0
}, {
id: 5,
name: "trap",
place: !0,
limit: 6,
layer: -1
}, {
id: 6,
name: "booster",
place: !0,
limit: 12,
sandboxLimit: 299,
layer: -1
}, {
id: 7,
name: "turret",
place: !0,
limit: 2,
layer: 1
}, {
id: 8,
name: "watchtower",
place: !0,
limit: 12,
layer: 1
}, {
id: 9,
name: "buff",
place: !0,
limit: 4,
layer: -1
}, {
id: 10,
name: "spawn",
place: !0,
limit: 1,
layer: -1
}, {
id: 11,
name: "sapling",
place: !0,
limit: 2,
layer: 0
}, {
id: 12,
name: "blocker",
place: !0,
limit: 3,
layer: -1
}, {
id: 13,
name: "teleporter",
place: !0,
limit: 2,
sandboxLimit: 299,
layer: -1
}];

// PROJECTILES:
[Link] = [{
indx: 0,
layer: 0,
src: "arrow_1",
dmg: 25,
speed: 1.6,
scale: 103,
range: 1000
}, {
indx: 1,
layer: 1,
dmg: 25,
scale: 20
}, {
indx: 0,
layer: 0,
src: "arrow_1",
dmg: 35,
speed: 2.5,
scale: 103,
range: 1200
}, {
indx: 0,
layer: 0,
src: "arrow_1",
dmg: 30,
speed: 2,
scale: 103,
range: 1200
}, {
indx: 1,
layer: 1,
dmg: 16,
scale: 20
}, {
indx: 0,
layer: 0,
src: "bullet_1",
dmg: 50,
speed: 3.6,
scale: 160,
range: 1400
}];

// WEAPONS:
[Link] = [{
id: 0,
type: 0,
name: "tool hammer",
desc: "tool for gathering all resources",
src: "hammer_1",
length: 140,
width: 140,
xOff: -3,
yOff: 18,
dmg: 25,
range: 65,
gather: 1,
speed: 300
}, {
id: 1,
type: 0,
age: 2,
name: "hand axe",
desc: "gathers resources at a higher rate",
src: "axe_1",
length: 140,
width: 140,
xOff: 3,
yOff: 24,
dmg: 30,
spdMult: 1,
range: 70,
gather: 2,
speed: 400
}, {
id: 2,
type: 0,
age: 8,
pre: 1,
name: "great axe",
desc: "deal more damage and gather more resources",
src: "great_axe_1",
length: 140,
width: 140,
xOff: -8,
yOff: 25,
dmg: 35,
spdMult: 1,
range: 75,
gather: 4,
speed: 400
}, {
id: 3,
type: 0,
age: 2,
name: "short sword",
desc: "increased attack power but slower move speed",
src: "sword_1",
iPad: 1.3,
length: 130,
width: 210,
xOff: -8,
yOff: 46,
dmg: 35,
spdMult: 0.85,
range: 110,
gather: 1,
speed: 300
}, {
id: 4,
type: 0,
age: 8,
pre: 3,
name: "katana",
desc: "greater range and damage",
src: "samurai_1",
iPad: 1.3,
length: 130,
width: 210,
xOff: -8,
yOff: 59,
dmg: 40,
spdMult: 0.8,
range: 118,
gather: 1,
speed: 300
}, {
id: 5,
type: 0,
age: 2,
name: "polearm",
desc: "long range melee weapon",
src: "spear_1",
iPad: 1.3,
length: 130,
width: 210,
xOff: -8,
yOff: 53,
dmg: 45,
knock: 0.2,
spdMult: 0.82,
range: 142,
gather: 1,
speed: 700
}, {
id: 6,
type: 0,
age: 2,
name: "bat",
desc: "fast long range melee weapon",
src: "bat_1",
iPad: 1.3,
length: 110,
width: 180,
xOff: -8,
yOff: 53,
dmg: 20,
knock: 0.7,
range: 110,
gather: 1,
speed: 300
}, {
id: 7,
type: 0,
age: 2,
name: "daggers",
desc: "really fast short range weapon",
src: "dagger_1",
iPad: 0.8,
length: 110,
width: 110,
xOff: 18,
yOff: 0,
dmg: 20,
knock: 0.1,
range: 65,
gather: 1,
hitSlow: 0.1,
spdMult: 1.13,
speed: 100
}, {
id: 8,
type: 0,
age: 2,
name: "stick",
desc: "great for gathering but very weak",
src: "stick_1",
length: 140,
width: 140,
xOff: 3,
yOff: 24,
dmg: 1,
spdMult: 1,
range: 70,
gather: 7,
speed: 400
}, {
id: 9,
type: 1,
age: 6,
name: "hunting bow",
desc: "bow used for ranged combat and hunting",
src: "bow_1",
req: ["wood", 4],
length: 120,
width: 120,
xOff: -6,
yOff: 0,
projectile: 0,
spdMult: 0.75,
speed: 600
}, {
id: 10,
type: 1,
age: 6,
name: "great hammer",
desc: "hammer used for destroying structures",
src: "great_hammer_1",
length: 140,
width: 140,
xOff: -9,
yOff: 25,
dmg: 10,
spdMult: 0.88,
range: 75,
sDmg: 7.5,
gather: 1,
speed: 400
}, {
id: 11,
type: 1,
age: 6,
name: "wooden shield",
desc: "blocks projectiles and reduces melee damage",
src: "shield_1",
length: 120,
width: 120,
shield: 0.2,
xOff: 6,
yOff: 0,
spdMult: 0.7
}, {
id: 12,
type: 1,
age: 8,
pre: 9,
name: "crossbow",
desc: "deals more damage and has greater range",
src: "crossbow_1",
req: ["wood", 5],
aboveHand: true,
armS: 0.75,
length: 120,
width: 120,
xOff: -4,
yOff: 0,
projectile: 2,
spdMult: 0.7,
speed: 700
}, {
id: 13,
type: 1,
age: 9,
pre: 12,
name: "repeater crossbow",
desc: "high firerate crossbow with reduced damage",
src: "crossbow_2",
req: ["wood", 10],
aboveHand: true,
armS: 0.75,
length: 120,
width: 120,
xOff: -4,
yOff: 0,
projectile: 3,
spdMult: 0.7,
speed: 230
}, {
id: 14,
type: 1,
age: 6,
name: "mc grabby",
desc: "steals resources from enemies",
src: "grab_1",
length: 130,
width: 210,
xOff: -8,
yOff: 53,
dmg: 0,
steal: 250,
knock: 0.2,
spdMult: 1.05,
range: 125,
gather: 0,
speed: 700
}, {
id: 15,
type: 1,
age: 9,
pre: 12,
name: "musket",
desc: "slow firerate but high damage and range",
src: "musket_1",
req: ["stone", 10],
aboveHand: true,
rec: 0.35,
armS: 0.6,
hndS: 0.3,
hndD: 1.6,
length: 205,
width: 205,
xOff: 25,
yOff: 0,
projectile: 5,
hideProjectile: true,
spdMult: 0.6,
speed: 1500
}];

// ITEMS:
[Link] = [{
group: [Link][0],
name: "apple",
desc: "restores 20 health when consumed",
req: ["food", 10],
consume: function(doer) {
return [Link](20, doer);
},
heal: 20,
scale: 22,
holdOffset: 15
}, {
age: 3,
group: [Link][0],
name: "cookie",
desc: "restores 40 health when consumed",
req: ["food", 15],
consume: function(doer) {
return [Link](40, doer);
},
heal: 40,
scale: 27,
holdOffset: 15
}, {
age: 7,
group: [Link][0],
name: "cheese",
desc: "restores 30 health and another 50 over 5 seconds",
req: ["food", 25],
consume: function(doer) {
if ([Link](30, doer) || [Link] < 100) {
[Link] = -10;
[Link] = doer;
[Link] = 5;
return true;
}
return false;
},
heal: 30,
scale: 27,
holdOffset: 15
}, {
group: [Link][1],
name: "wood wall",
desc: "provides protection for your village",
req: ["wood", 10],
projDmg: true,
health: 380,
scale: 50,
holdOffset: 20,
placeOffset: -5
}, {
age: 3,
group: [Link][1],
name: "stone wall",
desc: "provides improved protection for your village",
req: ["stone", 25],
health: 900,
scale: 50,
holdOffset: 20,
placeOffset: -5
}, {
age: 7,
group: [Link][1],
name: "castle wall",
desc: "provides powerful protection for your village",
req: ["stone", 35],
health: 1500,
scale: 52,
holdOffset: 20,
placeOffset: -5
}, {
group: [Link][2],
name: "spikes",
desc: "damages enemies when they touch them",
req: ["wood", 20, "stone", 5],
health: 400,
dmg: 20,
scale: 49,
spritePadding: -23,
holdOffset: 8,
placeOffset: -5
}, {
age: 5,
group: [Link][2],
name: "greater spikes",
desc: "damages enemies when they touch them",
req: ["wood", 30, "stone", 10],
health: 500,
dmg: 35,
scale: 52,
spritePadding: -23,
holdOffset: 8,
placeOffset: -5
}, {
age: 9,
group: [Link][2],
name: "poison spikes",
desc: "poisons enemies when they touch them",
req: ["wood", 35, "stone", 15],
health: 600,
dmg: 30,
pDmg: 5,
scale: 52,
spritePadding: -23,
holdOffset: 8,
placeOffset: -5
}, {
age: 9,
group: [Link][2],
name: "spinning spikes",
desc: "damages enemies when they touch them",
req: ["wood", 30, "stone", 20],
health: 500,
dmg: 45,
turnSpeed: 0.003,
scale: 52,
spritePadding: -23,
holdOffset: 8,
placeOffset: -5
}, {
group: [Link][3],
name: "windmill",
desc: "generates gold over time",
req: ["wood", 50, "stone", 10],
health: 400,
pps: 1,
turnSpeed: 0.0016,
spritePadding: 25,
iconLineMult: 12,
scale: 45,
holdOffset: 20,
placeOffset: 5
}, {
age: 5,
group: [Link][3],
name: "faster windmill",
desc: "generates more gold over time",
req: ["wood", 60, "stone", 20],
health: 500,
pps: 1.5,
turnSpeed: 0.0025,
spritePadding: 25,
iconLineMult: 12,
scale: 47,
holdOffset: 20,
placeOffset: 5
}, {
age: 8,
group: [Link][3],
name: "power mill",
desc: "generates more gold over time",
req: ["wood", 100, "stone", 50],
health: 800,
pps: 2,
turnSpeed: 0.005,
spritePadding: 25,
iconLineMult: 12,
scale: 47,
holdOffset: 20,
placeOffset: 5
}, {
age: 5,
group: [Link][4],
type: 2,
name: "mine",
desc: "allows you to mine stone",
req: ["wood", 20, "stone", 100],
iconLineMult: 12,
scale: 65,
holdOffset: 20,
placeOffset: 0
}, {
age: 5,
group: [Link][11],
type: 0,
name: "sapling",
desc: "allows you to farm wood",
req: ["wood", 150],
iconLineMult: 12,
colDiv: 0.5,
scale: 110,
holdOffset: 50,
placeOffset: -15
}, {
age: 4,
group: [Link][5],
name: "pit trap",
desc: "pit that traps enemies if they walk over it",
req: ["wood", 30, "stone", 30],
trap: true,
ignoreCollision: true,
hideFromEnemy: true,
health: 500,
colDiv: 0.2,
scale: 50,
holdOffset: 20,
placeOffset: -5
}, {
age: 4,
group: [Link][6],
name: "boost pad",
desc: "provides boost when stepped on",
req: ["stone", 20, "wood", 5],
ignoreCollision: true,
boostSpeed: 1.5,
health: 150,
colDiv: 0.7,
scale: 45,
holdOffset: 20,
placeOffset: -5
}, {
age: 7,
group: [Link][7],
doUpdate: true,
name: "turret",
desc: "defensive structure that shoots at enemies",
req: ["wood", 200, "stone", 150],
health: 800,
projectile: 1,
shootRange: 700,
shootRate: 2200,
scale: 43,
holdOffset: 20,
placeOffset: -5
}, {
age: 7,
group: [Link][8],
name: "platform",
desc: "platform to shoot over walls and cross over water",
req: ["wood", 20],
ignoreCollision: true,
zIndex: 1,
health: 300,
scale: 43,
holdOffset: 20,
placeOffset: -5
}, {
age: 7,
group: [Link][9],
name: "healing pad",
desc: "standing on it will slowly heal you",
req: ["wood", 30, "food", 10],
ignoreCollision: true,
healCol: 15,
health: 400,
colDiv: 0.7,
scale: 45,
holdOffset: 20,
placeOffset: -5
}, {
age: 9,
group: [Link][10],
name: "spawn pad",
desc: "you will spawn here when you die but it will dissapear",
req: ["wood", 100, "stone", 100],
health: 400,
ignoreCollision: true,
spawnPoint: true,
scale: 45,
holdOffset: 20,
placeOffset: -5
}, {
age: 7,
group: [Link][12],
name: "blocker",
desc: "blocks building in radius",
req: ["wood", 30, "stone", 25],
ignoreCollision: true,
blocker: 300,
health: 400,
colDiv: 0.7,
scale: 45,
holdOffset: 20,
placeOffset: -5
}, {
age: 7,
group: [Link][13],
name: "teleporter",
desc: "teleports you to a random point on the map",
req: ["wood", 60, "stone", 60],
ignoreCollision: true,
teleport: true,
health: 200,
colDiv: 0.7,
scale: 45,
holdOffset: 20,
placeOffset: -5
}];

// ASSIGN IDS:
for (var i = 0; i < [Link]; ++i) {
[Link][i].id = i;
}

// TROLOLOLOL:
if (typeof window !== "undefined") {
function shuffle(a) {
for (let i = [Link] - 1; i > 0; i--) {
const j = [Link]([Link]() * (i + 1));
[a[i], a[j]] = [a[j], a[i]];
}
return a;
}
}

/***/ }),

// GLOBAL MAPMANAGER:
[Link] = {}

/***/ }),

/***/ "./src/js/data/[Link]":
/*!**************************************!*\
!*** ./src/js/data/[Link] ***!
\**************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// SET OBJECT GRIDS:

var tmpX, tmpY;
var tmpS = [Link]/[Link];
[Link] = function(obj) {
var objX = [Link]([Link], [Link](0, obj.x));
var objY = [Link]([Link], [Link](0, obj.y));
for (var x = 0; x < [Link]; ++x) {
tmpX = x * tmpS;
for (var y = 0; y < [Link]; ++y) {
tmpY = y * tmpS;
if (objX + [Link] >= tmpX && objX - [Link] <= tmpX +
tmpS &&
objY + [Link] >= tmpY && objY - [Link] <= tmpY +
tmpS) {
if (![Link][x + "_" + y])
[Link][x + "_" + y] = [];
[Link][x + "_" + y].push(obj);
[Link](x + "_" + y);
}
}
}
};
// REMOVE OBJECT FROM GRID:
[Link] = function(obj) {
var tmpIndx;
for (var i = 0; i < [Link]; ++i) {
tmpIndx = [Link][[Link][i]].indexOf(obj);
if (tmpIndx >= 0) {
[Link][[Link][i]].splice(tmpIndx, 1);
}
}
};

// DISABLE OBJ:
[Link] = function(obj) {
[Link] = false;
if (server) {
if ([Link] && [Link]) [Link] -= [Link];
[Link](obj);
var tmpIndx = [Link](obj);
if (tmpIndx >= 0) {
[Link](tmpIndx, 1);
}
}
};

// HIT OBJECT:
[Link] = function(tmpObj, tmpDir) {
for (var p = 0; p < [Link]; ++p) {
if (players[p].active) {
if ([Link][players[p].id]) {
if (![Link]) [Link](players[p].id, "Q",
[Link]);
else if (players[p].canSee(tmpObj))
[Link](players[p].id, "L", [Link](tmpDir,
1), [Link]);
} if (![Link] && [Link] == players[p])
players[p].changeItemCount([Link], -1);
}
}
};

// GET GRID ARRAY:

// ADD NEW:
var tmpObj;
[Link] = function(sid, x, y, dir, s, type, data, setSID, owner) {
tmpObj = null;
for (var i = 0; i < [Link]; ++i) {
if (gameObjects[i].sid == sid) {
tmpObj = gameObjects[i];
break;
}
} if (!tmpObj) {
for (var i = 0; i < [Link]; ++i) {
if (!gameObjects[i].active) {
tmpObj = gameObjects[i];
break;
}
}
} if (!tmpObj) {
tmpObj = new GameObject(sid);
[Link](tmpObj);
}
if (setSID)
[Link] = sid;
[Link](x, y, dir, s, type, data, owner);
if (server) {
[Link](tmpObj);
if ([Link])
[Link](tmpObj);
}
};

// DISABLE BY SID:
[Link] = function(sid) {
for(const object of gameObjects){
if([Link] != sid) continue;

[Link]([Link](object), 1);
break;
}

/*
for(var i = 0; i < [Link]; ++i){
if(gameObjects[i].sid == sid){
[Link](gameObjects[i]);
break;
}
}
*/
};

// REMOVE ALL FROM PLAYER:

[Link] = function(sid, server) {
const objects = [Link]((object) => [Link] &&
[Link] == sid);
for(const object of objects){
[Link]([Link](object), 1);
}

/*
for (var i = 0; i < [Link]; ++i) {
if (gameObjects[i].active && gameObjects[i].owner &&
gameObjects[i].[Link] == sid) {
[Link](gameObjects[i]);
}
}
if (server) {
[Link]("R", sid);
}
*/
};

// FETCH SPAWN OBJECT:

[Link] = function(sid) {
var tmpLoc = null;
for (var i = 0; i < [Link]; ++i) {
tmpObj = gameObjects[i];
if ([Link] && [Link] && [Link] == sid &&
[Link]) {
tmpLoc = [tmpObj.x, tmpObj.y];
[Link](tmpObj);
[Link]("Q", [Link]);
if ([Link]) {
[Link]([Link], -1);
}
break;
}
}
return tmpLoc;
};

// CHECK IF PLACABLE:
[Link] = function(x, y, s, sM, indx, ignoreWater,
placer, objects) {
for (var i = 0; i < [Link]; ++i) {
var blockS = (objects[i].blocker?
objects[i].blocker:objects[i].getScale(sM,
objects[i].isItem));
if (objects[i].active && [Link](x, y, objects[i].x,
objects[i].y) < (s +
blockS))
return false;
} if (!ignoreWater && indx != 18 && y >= ([Link] / 2) -
([Link] / 2) && y <=
([Link] / 2) + ([Link] / 2)) {
return false;
}
return true;
};

// ADD PROJECTILE:
[Link] = function(x, y, dir, range, indx) {
var tmpData = [Link][indx];
var tmpProj;
for (var i = 0; i < [Link]; ++i) {
if (!projectiles[i].active) {
tmpProj = projectiles[i];
break;
}
}
if (!tmpProj) {
tmpProj = new Projectile(players, UTILS);
[Link](tmpProj);
}
[Link](indx, x, y, dir, [Link], range, [Link]);
};

// CHECK PLAYER COLLISION:

[Link] = function(player, other, delta) {
delta = delta||1;
var dx = player.x - other.x;
var dy = player.y - other.y;
var tmpLen = [Link] + [Link];
if (mathABS(dx) <= tmpLen || mathABS(dy) <= tmpLen) {
tmpLen = [Link] + ([Link]?
[Link]():[Link]);
var tmpInt = mathSQRT(dx * dx + dy * dy) - tmpLen;
if (tmpInt <= 0) {
if (![Link]) {
var tmpDir = [Link](player.x, player.y,
other.x, other.y);
var tmpDist = [Link](player.x, player.y,
other.x, other.y);
if ([Link]) {
tmpInt = (tmpInt * -1) / 2;
player.x += (tmpInt * mathCOS(tmpDir));
player.y += (tmpInt * mathSIN(tmpDir));
other.x -= (tmpInt * mathCOS(tmpDir));
other.y -= (tmpInt * mathSIN(tmpDir));
} else {
player.x = other.x + (tmpLen * mathCOS(tmpDir));
player.y = other.y + (tmpLen * mathSIN(tmpDir));
[Link] *= 0.75;
[Link] *= 0.75;
}
if ([Link] && [Link] != player && !([Link]
&&

};

/***/ }),

/***/ "./src/js/data/[Link]":
/*!*******************************!*\
!*** ./src/js/data/[Link] ***!
\*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var LangFilter = __webpack_require__(/! bad-words / "./node_modules/bad-

words/lib/[Link]");
var langFilter = new LangFilter();
var newProfane = ['jew', 'black', 'baby', 'child', 'white',
'porn', 'pedo', 'trump', 'clinton', 'hitler', 'nazi',
'gay', 'pride', 'sex', 'pleasure', 'touch', 'poo',
'kids',
'rape', 'white power', 'nigga', 'nig nog', 'doggy',
'rapist',
'boner', 'nigger', 'nigg', 'finger', 'nogger', 'nagger',
'nig',
'fag', 'gai', 'pole', 'stripper', "penis", 'vagina',
'pussy',
'nazi', 'hitler', 'stalin', 'burn', 'chamber', 'cock',
'peen', 'dick', 'spick', 'nieger', 'die', 'satan', 'n|
ig', 'nlg',
'cunt', 'c0ck', 'fag', 'lick', 'condom', 'anal', 'shit',
'phile',
'little', 'kids', 'free KR', 'tiny', 'sidney', 'ass',
'kill', '.io',
'(dot)', '[dot]', 'mini', 'whiore', 'whore', 'faggot',
'github',
'1337', '666', 'satan',
'senpa', 'discord', 'd1scord', 'mistik', '.io',
'[Link]', 'sidney', 'sid', 'senpaio', 'vries', 'asa',
];
[Link](...newProfane);

// SPAWN:
[Link] = function(moofoll) {
[Link] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0];
[Link] = 0;

[Link] = true;
[Link] = true;
[Link] = false;
[Link] = false;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = {};
[Link] = 0;
[Link] = {};
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = -1;
[Link] = 0;
[Link] = 0;
[Link] = {};
[Link] = 0;
[Link] = 300;
[Link] = 0;
[Link] = 1;
[Link] = 0;
[Link] = 2;
[Link] = 0;
this.x = 0;
this.y = 0;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = 1;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = 0;
[Link] = 100;
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link]();
[Link](moofoll);
[Link] = [0, 3, 6, 10];
[Link] = [0];
[Link] = 0;
[Link] = [];
[Link] = {
[0]: 0,
[1]: 0,
[2]: 0,
[3]: 0,
[4]: 0,
[5]: 0,
[6]: 0,
[7]: 0,
[8]: 0,
[9]: 0,
[10]: 0,
[11]: 0,
[12]: 0,
[13]: 0,
[14]: 0,
[15]: 0,
[53]: 0
};
};
[Link] = function (id) {
let findindx = [Link](ids => ids == id);
if (findindx != -1) {
return findindx;
} else {
return [Link](id, [Link]);
}
};
// RESET MOVE DIR:
[Link] = function() {
[Link] = undefined;
};

// RESET RESOURCES:
[Link] = function(moofoll) {
for (var i = 0; i < [Link]; ++i) {
this[[Link][i]] = moofoll?100:0;
}
};

// ADD ITEM:
[Link] = function(id) {
var tmpItem = [Link][id];
if (tmpItem) {
for (var i = 0; i < [Link]; ++i) {
if ([Link][[Link][i]].group == [Link]) {
if ([Link] == [Link][i])
[Link] = id;
[Link][i] = id;
return true;
}
}
[Link](id);
return true;
}
return false;
};

// SET USER DATA:

[Link] = function(data) {
if (data) {
// SET INITIAL NAME:
[Link] = "unknown";
// VALIDATE NAME:
var name = [Link] + "";
name = [Link](0, [Link]);
name = [Link](/[^\w:\/? -]+/gmi, " "); // USE SPACE
SO WE CAN CHECK PROFANITY
name = [Link](/[^\x00-\x7F]/g, " ");
name = [Link]();

// CHECK IF IS PROFANE:
var isProfane = false;
var convertedName = [Link]().replace(/\s/g,
"").replace(/1/g, "i").replace(/0/g, "o").replace(/5/g, "s");
for (var word of [Link]) {
if ([Link](word) != -1) {
isProfane = true;
break;
}
}
if ([Link] > 0 && !isProfane) {
[Link] = name;
}

// SKIN:
[Link] = 0;
if ([Link][[Link]])
[Link] = [Link];
}
};

// GET DATA TO SEND:

[Link] = function() {
return [
[Link],
[Link],
[Link],
[Link](this.x, 2),
[Link](this.y, 2),
[Link]([Link], 3),
[Link],
[Link],
[Link],
[Link]
];
};

// SET DATA:
[Link] = function(data) {
[Link] = data[0];
[Link] = data[1];
[Link] = data[2];
this.x = data[3];
this.y = data[4];
[Link] = data[5];
[Link] = data[6];
[Link] = data[7];
[Link] = data[8];
[Link] = data[9];
};
// UPDATE:
var timerCount = 0;
[Link] = function(tmpObj, tmp) {
return [Link](THIS => [Link] == tmp);
}
[Link] = function(delta) {
if (![Link]) return;

// SHAME SHAME SHAME:

if ([Link] > 0) {
[Link] -= delta;
if ([Link] <= 0) {
[Link] = 0;
[Link] = 0;
}
}

// REGENS AND AUTO:

timerCount -= delta;
if (timerCount <= 0) {
var regenAmount = ([Link] && [Link]?
[Link]) +
([Link] && [Link]?
[Link]);
if (regenAmount) {
[Link](regenAmount, this);
} if ([Link]) {
[Link](-[Link],
[Link]);
[Link] -= 1;
if ([Link] <= 0)
[Link] = 0;
} if ([Link]) {
[Link]([Link], this);
}
timerCount = 1000;
}

// CHECK KILL:
if (![Link]) return;

// SLOWER:
if ([Link] < 1) {
[Link] += 0.0008 * delta;
if ([Link] > 1) [Link] = 1;
}

// MOVE:
[Link] += delta;
if ([Link] || [Link]) [Link] = 0;
if ([Link]) {
[Link] = 0;
[Link] = 0;
} else {
let gear = {
skin: [Link](hats, [Link]),
tail: [Link](accessories, [Link])
};
let spdMult = ([Link] >= 0 ? 0.5 : 1) *
([Link][[Link]].spdMult || 1) * ([Link] ? [Link] ||
1 : 1) * ([Link] ? [Link] || 1 : 1) * (this.y <=
[Link] ? [Link] && [Link] ? 1 : [Link] : 1) *
[Link];

if (![Link] && this.y >= ([Link] / 2) -

([Link] / 2) &&
this.y <= ([Link] / 2) + ([Link] / 2))
{
if ([Link] && [Link]) {
spdMult *= 0.75;
[Link] += [Link] * 0.4 * delta;
} else {
spdMult *= 0.33;
[Link] += [Link] * delta;
}
}
var xVel = ([Link]!=undefined)?mathCOS([Link]):0;
var yVel = ([Link]!=undefined)?mathSIN([Link]):0;
var length = mathSQRT(xVel * xVel + yVel * yVel);
if (length != 0) {
xVel /= length;
yVel /= length;
}
if (xVel) [Link] += xVel * [Link] * spdMult * delta;
if (yVel) [Link] += yVel * [Link] * spdMult * delta;
}

// OBJECT COLL:
[Link] = 0;
[Link] = false;
[Link] = 0;
var tmpList;
var tmpSpeed = [Link](0, 0, [Link] * delta, [Link]
* delta);
var depth = [Link](4, [Link](1, [Link](tmpSpeed / 40)));
var tMlt = 1 / depth;
for (var i = 0; i < depth; ++i) {
if ([Link])
this.x += ([Link] * delta) * tMlt;
if ([Link])
this.y += ([Link] * delta) * tMlt;
tmpList = [Link](this.x, this.y,
[Link]);
for (var x = 0; x < [Link]; ++x) {
for (var y = 0; y < tmpList[x].length; ++y) {
if (tmpList[x][y].active)
[Link](this, tmpList[x][y],
tMlt);
}
}
}

// PLAYER COLLISIONS:
var tmpIndx = [Link](this);
for (var i = tmpIndx + 1; i < [Link]; ++i) {
if (players[i] != this && players[i].alive)
[Link](this, players[i]);
}

// DECEL:
if ([Link]) {
[Link] *= mathPOW([Link], delta);
if ([Link] <= 0.01 && [Link] >= -0.01) [Link] = 0;
} if ([Link]) {
[Link] *= mathPOW([Link], delta);
if ([Link] <= 0.01 && [Link] >= -0.01) [Link] = 0;
}

// MAP BOUNDARIES:
if (this.x - [Link] < 0) {
this.x = [Link];
} else if (this.x + [Link] > [Link]) {
this.x = [Link] - [Link];
} if (this.y - [Link] < 0) {
this.y = [Link];
} else if (this.y + [Link] > [Link]) {
this.y = [Link] - [Link];
}

// USE WEAPON OR TOOL:

if ([Link] < 0) {
if ([Link][[Link]] > 0) {
[Link][[Link]] -= delta;
[Link] = [Link];
} else if ([Link] || [Link]) {
var worked = true;
if ([Link][[Link]].gather != undefined) {
[Link](players);
} else if ([Link][[Link]].projectile !=
undefined &&
[Link]([Link][[Link]],
([Link]?[Link]))) {
[Link]([Link][[Link]],
([Link]?[Link]));
[Link] = 0;
var tmpIndx =
[Link][[Link]].projectile;
var projOffset = [Link] * 2;
var aMlt = ([Link]&&[Link])?
[Link];
if ([Link][[Link]].rec) {
[Link] -= [Link][[Link]].rec *
mathCOS([Link]);
[Link] -= [Link][[Link]].rec *
mathSIN([Link]);
}
[Link](this.x+
(projOffset*mathCOS([Link])),
this.y+
(projOffset*mathSIN([Link])), [Link], [Link][tmpIndx].range*aMlt,

};

// ADD WEAPON XP:

[Link] = function(amnt) {
if (![Link][[Link]])
[Link][[Link]] = 0;
[Link][[Link]] += amnt;
};

// EARN XP:
[Link] = function(amount) {
if ([Link] < [Link]) {
[Link] += amount;
if ([Link] >= [Link]) {
if ([Link] < [Link]) {
[Link]++;
[Link] = 0;
[Link] *= 1.2;
} else {
[Link] = [Link];
}
[Link]++;
[Link]([Link], "U", [Link],
[Link]);
[Link]([Link], "T", [Link], [Link]([Link],
1), [Link]);
} else {
[Link]([Link], "T", [Link]);
}
}
};

// CHANGE HEALTH:
[Link] = function(amount, doer) {
if (amount > 0 && [Link] >= [Link])
return false
if (amount < 0 && [Link])
amount *= [Link]||1;
if (amount < 0 && [Link])
amount *= [Link]||1;
if (amount < 0)
[Link] = [Link]();
[Link] += amount;
if ([Link] > [Link]) {
amount -= ([Link] - [Link]);
[Link] = [Link];
}
if ([Link] <= 0)
[Link](doer);
for (var i = 0; i < [Link]; ++i) {
if ([Link][players[i].id])
[Link](players[i].id, "O", [Link],
[Link]([Link]));
}
if (doer && [Link](this) && !(doer == this && amount < 0)) {
[Link]([Link], "8", [Link](this.x),
[Link](this.y), [Link](-amount), 1);
}
return true;
};

// KILL:
[Link] = function(doer) {
if (doer && [Link]) {
[Link]++;
if ([Link] && [Link]) scoreCallback(doer,
[Link]([Link] / 2));
else scoreCallback(doer,
[Link]([Link]*100*(([Link]&&[Link])?[Link])));
[Link]([Link], "N", "kills", [Link], 1);
}
[Link] = false;
[Link]([Link], "P");
iconCallback();
};

// ADD RESOURCE:
[Link] = function(type, amount, auto) {
if (!auto && amount > 0)
[Link](amount);
if (type == 3) {
scoreCallback(this, amount, true);
} else {
this[[Link][type]] += amount;
[Link]([Link], "N", [Link][type],
this[[Link][type]], 1);
}
};

// CHANGE ITEM COUNT:

[Link] = function(index, value) {
[Link][index] = [Link][index]||0;
[Link][index] += value;
[Link]([Link], "S", index, [Link][index]);
};

// BUILD:
[Link] = function(item) {
var tmpS = ([Link] + [Link] + ([Link]||0));
var tmpX = this.x + (tmpS * mathCOS([Link]));
var tmpY = this.y + (tmpS * mathSIN([Link]));
if ([Link](item) && !([Link] && ([Link] &&
[Link]))
&& ([Link] || [Link](tmpX, tmpY,
[Link],
0.6,
[Link], false, this))) {
var worked = false;
if ([Link]) {
if ([Link]) {
var timeSinceHit = [Link]() - [Link];
[Link] = 0;
if (timeSinceHit <= 120) {
[Link]++;
if ([Link] >= 8) {
[Link] = 30000;
[Link] = 0;
}
} else {
[Link] -= 2;
if ([Link] <= 0) {
[Link] = 0;
}
}
}
if ([Link] <= 0)
worked = [Link](this);
} else {
worked = true;
if ([Link]) {
[Link]([Link], 1);
}
if ([Link])
[Link] += [Link];
[Link]([Link], tmpX, tmpY,
[Link], [Link],
[Link], item, false, this);
}
if (worked) {
[Link](item);
[Link] = -1;
}
}
};

// HAS RESOURCES:
[Link] = function(item, mult) {
for (var i = 0; i < [Link];) {
if (this[[Link][i]] < [Link]([Link][i + 1] * (mult||
1)))
return false;
i+=2;
}
return true;
};

// USE RESOURCES:
[Link] = function(item, mult) {
if ([Link])
return;
for (var i = 0; i < [Link];) {
[Link]([Link]([Link][i]), -
[Link]([Link][i+1]*(mult||1)));
i+=2;
}
};

// CAN BUILD:
[Link] = function(item) {
if ([Link])
return true;
if ([Link] && [Link][[Link]] >=
[Link])
return false;
return [Link](item);
};

// GATHER:
[Link] = function() {

// SHOW:
[Link] = 0;

// SLOW MOVEMENT:
[Link] -= ([Link][[Link]].hitSlow||0.3);
if ([Link] < 0)
[Link] = 0;

// VARIANT DMG:
var tmpVariant = [Link](this);
var applyPoison = [Link];
var variantDmg = [Link];

// CHECK IF HIT GAME OBJECT:

var hitObjs = {};
var tmpDist, tmpDir, tmpObj, hitSomething;
var tmpList = [Link](this.x, this.y,
[Link][[Link]].range);
for (var t = 0; t < [Link]; ++t) {
for (var i = 0; i < tmpList[t].length; ++i) {
tmpObj = tmpList[t][i];
if ([Link] && ![Link] && !
hitObjs[[Link]] && [Link](this)) {
tmpDist = [Link](this.x, this.y, tmpObj.x,
tmpObj.y) - [Link];
if (tmpDist <= [Link][[Link]].range) {
tmpDir = [Link](tmpObj.x, tmpObj.y,
this.x, this.y);
if ([Link](tmpDir, [Link]) <=
[Link]) {
hitObjs[[Link]] = 1;
if ([Link]) {
if ([Link](-
[Link][[Link]].dmg*(variantDmg)*

([Link][[Link]].sDmg||1)*([Link]&&[Link]?
[Link]), this)) {
for (var x = 0; x < [Link];)
{

[Link]([Link]([Link][x]), [Link][x+1]);
x+=2;
}
[Link](tmpObj);
}
} else {

[Link](4*[Link][[Link]].gather);
var count =
[Link][[Link]].gather+([Link]==3?4:0);
if ([Link] && [Link]) {
[Link](3, 1);
} [Link]([Link], count);
}
hitSomething = true;
[Link](tmpObj, tmpDir);
}
}
}
}
}

// CHECK IF HIT PLAYER:

for (var i = 0; i < [Link] + [Link]; ++i) {
tmpObj = players[i]||ais[[Link]];
if (tmpObj != this && [Link] && !([Link] &&
[Link] == [Link])) {
tmpDist = [Link](this.x, this.y, tmpObj.x,
tmpObj.y) - ([Link] * 1.8);
if (tmpDist <= [Link][[Link]].range) {
tmpDir = [Link](tmpObj.x, tmpObj.y, this.x,
this.y);
if ([Link](tmpDir, [Link]) <=
[Link]) {

// STEAL RESOURCES:
var stealCount =
[Link][[Link]].steal;
if (stealCount && [Link]) {
stealCount = [Link](([Link]||0),
stealCount);
[Link](3, stealCount);
[Link](3, -stealCount);
}

// MELEE HIT PLAYER:

}
}
}
}

// SEND FOR ANIMATION:

[Link](hitSomething?1:0);
};

// SEND ANIMATION:
[Link] = function(hit) {
for (var i = 0; i < [Link]; ++i) {
if ([Link][players[i].id] && [Link](players[i])) {
[Link](players[i].id, "K", [Link], hit?1:0,
[Link]);
}
}
};

// ANIMATE:
var tmpRatio = 0;
var animIndex = 0;
[Link] = function(delta) {
if ([Link] > 0) {
[Link] -= delta;
if ([Link] <= 0) {
[Link] = 0;
[Link] = 0;
tmpRatio = 0;
animIndex = 0;
} else {
if (animIndex == 0) {
tmpRatio += delta / ([Link] *
[Link]);
[Link] = [Link](0, [Link],
[Link](1, tmpRatio));
if (tmpRatio >= 1) {
tmpRatio = 1;
animIndex = 1;
}
} else {
tmpRatio -= delta / ([Link] * (1-
[Link]));
[Link] = [Link](0, [Link],
[Link](0, tmpRatio));
}
}
}
};

// GATHER ANIMATION:
[Link] = function(didHit, index) {
[Link] = [Link] = [Link][index].speed;
[Link] = (didHit?-[Link]:-[Link]);
tmpRatio = 0;
animIndex = 0;
};

// CAN SEE:
[Link] = function(other) {
if (!other) return false;
if ([Link] && [Link] && [Link]
>= [Link]) return false;
var dx = mathABS(other.x - this.x) - [Link];
var dy = mathABS(other.y - this.y) - [Link];
return dx <= ([Link] / 2) * 1.3 && dy <=
([Link] / 2) * 1.3;
};

};

/***/ }),

[Link] = function (players, ais, objectManager, items, config,

UTILS, server) {

// INIT:
[Link] = function(indx, x, y, dir, spd, dmg, rng, scl, owner) {
[Link] = true;
[Link] = indx;
this.x = x;
this.y = y;
[Link] = dir;
[Link] = true;
[Link] = spd;
[Link] = dmg;
[Link] = scl;
[Link] = rng;
[Link] = owner;
if (server)
[Link] = {};
};

// UPDATE:
var objectsHit = [];
var tmpObj;
[Link] = function(delta) {
if ([Link]) {
var tmpSpeed = [Link] * delta;
var tmpScale;
if (![Link]) {
this.x += tmpSpeed * [Link]([Link]);
this.y += tmpSpeed * [Link]([Link]);
[Link] -= tmpSpeed;
if ([Link] <= 0) {
this.x += [Link] * [Link]([Link]);
this.y += [Link] * [Link]([Link]);
tmpSpeed = 1;
[Link] = 0;
[Link] = false;
}
} else {
[Link] = false;
}
if (server) {
for (var i = 0; i < [Link]; ++i) {
if (![Link][players[i].id] &&
players[i].canSee(this)) {
[Link][players[i].id] = 1;
[Link](players[i].id, "X", [Link](this.x,
1), [Link](this.y, 1),
[Link]([Link], 2),
[Link]([Link], 1), [Link], [Link], [Link], [Link]);
}
}
[Link] = 0;
for (var i = 0; i < [Link] + [Link]; ++i) {
tmpObj = players[i]||ais[[Link]];
if ([Link] && tmpObj != [Link] && !
([Link] && [Link] == [Link])) {
if ([Link]([Link],
[Link], tmpObj.x+[Link],
tmpObj.y+[Link], this.x,
this.y, this.x+(tmpSpeed*[Link]([Link])),
this.y+
(tmpSpeed*[Link]([Link])))) {
[Link](tmpObj);
}
}
}
var tmpList = [Link](this.x, this.y,
[Link]);
for (var x = 0; x < [Link]; ++x) {
for (var y = 0; y < tmpList[x].length; ++y) {
tmpObj = tmpList[x][y];
tmpScale = [Link]();
if ([Link] && !([Link] ==
[Link]) && ([Link] <= [Link]) &&
[Link](tmpObj) < 0 && !
[Link] && [Link](tmpObj.x-tmpScale, tmpObj.y-tmpScale,
tmpObj.x+tmpScale, tmpObj.y+tmpScale,

this.x, this.y, this.x+(tmpSpeed*[Link]([Link])), this.y+

(tmpSpeed*[Link]([Link])))) {
[Link](tmpObj);
}
}
}

// HIT OBJECTS:
if ([Link] > 0) {
var hitObj = null;
var shortDist = null;
var tmpDist = null;
for (var i = 0; i < [Link]; ++i) {
tmpDist = [Link](this.x, this.y,
objectsHit[i].x, objectsHit[i].y);
if (shortDist == null || tmpDist < shortDist) {
shortDist = tmpDist;
hitObj = objectsHit[i];
}
}
if ([Link] || [Link]) {
var tmpSd = 0.3 * ([Link]||1);
[Link] += tmpSd * [Link]([Link]);
[Link] += tmpSd * [Link]([Link]);
if ([Link] == undefined || (!
([Link][[Link]].shield &&

players[i].changeItemCount([Link], -1);
}

}
}
[Link] = false;
for (var i = 0; i < [Link]; ++i) {
if ([Link][players[i].id])
[Link](players[i].id, "Y", [Link],
[Link](shortDist, 1));
}
}
}
}
};
};

/***/ }),

/***/ "./src/js/data/[Link]":
/*!******************************************!*\
!*** ./src/js/data/[Link] ***!
\******************************************/
/*! no static exports found */
/***/ (function(module, exports) {

/***/ }),

/***/ "./src/js/data/[Link]":
/*!******************************!*\
!*** ./src/js/data/[Link] ***!
\******************************/
/*! no static exports found */
/***/ (function(module, exports) {

// STORE HATS:
[Link] = [{
id: 45,
name: "Shame!",
dontSell: true,
price: 0,
scale: 120,
desc: "hacks are for losers"
}, {
id: 51,
name: "Moo Cap",
price: 0,
scale: 120,
desc: "coolest mooer around"
}, {
id: 50,
name: "Apple Cap",
price: 0,
scale: 120,
desc: "apple farms remembers"
}, {
id: 28,
name: "Moo Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 29,
name: "Pig Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 30,
name: "Fluff Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 36,
name: "Pandou Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 37,
name: "Bear Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 38,
name: "Monkey Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 44,
name: "Polar Head",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 35,
name: "Fez Hat",
price: 0,
scale: 120,
desc: "no effect"
}, {
id: 42,
name: "Enigma Hat",
price: 0,
scale: 120,
desc: "join the enigma army"
}, {
id: 43,
name: "Blitz Hat",
price: 0,
scale: 120,
desc: "hey everybody i'm blitz"
}, {
id: 49,
name: "Bob XIII Hat",
price: 0,
scale: 120,
desc: "like and subscribe"
}, {
id: 57,
name: "Pumpkin",
price: 50,
scale: 120,
desc: "Spooooky"
}, {
id: 8,
name: "Bummle Hat",
price: 100,
scale: 120,
desc: "no effect"
}, {
id: 2,
name: "Straw Hat",
price: 500,
scale: 120,
desc: "no effect"
}, {
id: 15,
name: "Winter Cap",
price: 600,
scale: 120,
desc: "allows you to move at normal speed in snow",
coldM: 1
}, {
id: 5,
name: "Cowboy Hat",
price: 1000,
scale: 120,
desc: "no effect"
}, {
id: 4,
name: "Ranger Hat",
price: 2000,
scale: 120,
desc: "no effect"
}, {
id: 18,
name: "Explorer Hat",
price: 2000,
scale: 120,
desc: "no effect"
}, {
id: 31,
name: "Flipper Hat",
price: 2500,
scale: 120,
desc: "have more control while in water",
watrImm: true
}, {
id: 1,
name: "Marksman Cap",
price: 3000,
scale: 120,
desc: "increases arrow speed and range",
aMlt: 1.3
}, {
id: 10,
name: "Bush Gear",
price: 3000,
scale: 160,
desc: "allows you to disguise yourself as a bush"
}, {
id: 48,
name: "Halo",
price: 3000,
scale: 120,
desc: "no effect"
}, {
id: 6,
name: "Soldier Helmet",
price: 4000,
scale: 120,
desc: "reduces damage taken but slows movement",
spdMult: 0.94,
dmgMult: 0.75
}, {
id: 23,
name: "Anti Venom Gear",
price: 4000,
scale: 120,
desc: "makes you immune to poison",
poisonRes: 1
}, {
id: 13,
name: "Medic Gear",
price: 5000,
scale: 110,
desc: "slowly regenerates health over time",
healthRegen: 3
}, {
id: 9,
name: "Miners Helmet",
price: 5000,
scale: 120,
desc: "earn 1 extra gold per resource",
extraGold: 1
}, {
id: 32,
name: "Musketeer Hat",
price: 5000,
scale: 120,
desc: "reduces cost of projectiles",
projCost: 0.5
}, {
id: 7,
name: "Bull Helmet",
price: 6000,
scale: 120,
desc: "increases damage done but drains health",
healthRegen: -5,
dmgMultO: 1.5,
spdMult: 0.96
}, {
id: 22,
name: "Emp Helmet",
price: 6000,
scale: 120,
desc: "turrets won't attack but you move slower",
antiTurret: 1,
spdMult: 0.7
}, {
id: 12,
name: "Booster Hat",
price: 6000,
scale: 120,
desc: "increases your movement speed",
spdMult: 1.16
}, {
id: 26,
name: "Barbarian Armor",
price: 8000,
scale: 120,
desc: "knocks back enemies that attack you",
dmgK: 0.6
}, {
id: 21,
name: "Plague Mask",
price: 10000,
scale: 120,
desc: "melee attacks deal poison damage",
poisonDmg: 5,
poisonTime: 6
}, {
id: 46,
name: "Bull Mask",
price: 10000,
scale: 120,
desc: "bulls won't target you unless you attack them",
bullRepel: 1
}, {
id: 14,
name: "Windmill Hat",
topSprite: true,
price: 10000,
scale: 120,
desc: "generates points while worn",
pps: 1.5
}, {
id: 11,
name: "Spike Gear",
topSprite: true,
price: 10000,
scale: 120,
desc: "deal damage to players that damage you",
dmg: 0.45
}, {
id: 53,
name: "Turret Gear",
topSprite: true,
price: 10000,
scale: 120,
desc: "you become a walking turret",
turret: {
proj: 1,
range: 700,
rate: 2500
},
spdMult: 0.7
}, {
id: 20,
name: "Samurai Armor",
price: 12000,
scale: 120,
desc: "increased attack speed and fire rate",
atkSpd: 0.78
}, {
id: 58,
name: "Dark Knight",
price: 12000,
scale: 120,
desc: "restores health when you deal damage",
healD: 0.4
}, {
id: 27,
name: "Scavenger Gear",
price: 15000,
scale: 120,
desc: "earn double points for each kill",
kScrM: 2
}, {
id: 40,
name: "Tank Gear",
price: 15000,
scale: 120,
desc: "increased damage to buildings but slower movement",
spdMult: 0.3,
bDmg: 3.3
}, {
id: 52,
name: "Thief Gear",
price: 15000,
scale: 120,
desc: "steal half of a players gold when you kill them",
goldSteal: 0.5
}, {
id: 55,
name: "Bloodthirster",
price: 20000,
scale: 120,
desc: "Restore Health when dealing damage. And increased damage",
healD: 0.25,
dmgMultO: 1.2,
}, {
id: 56,
name: "Assassin Gear",
price: 20000,
scale: 120,
desc: "Go invisible when not moving. Can't eat. Increased speed",
noEat: true,
spdMult: 1.1,
invisTimer: 1000
}];

// STORE ACCESSORIES:
[Link] = [{
id: 12,
name: "Snowball",
price: 1000,
scale: 105,
xOff: 18,
desc: "no effect"
}, {
id: 9,
name: "Tree Cape",
price: 1000,
scale: 90,
desc: "no effect"
}, {
id: 10,
name: "Stone Cape",
price: 1000,
scale: 90,
desc: "no effect"
}, {
id: 3,
name: "Cookie Cape",
price: 1500,
scale: 90,
desc: "no effect"
}, {
id: 8,
name: "Cow Cape",
price: 2000,
scale: 90,
desc: "no effect"
}, {
id: 11,
name: "Monkey Tail",
price: 2000,
scale: 97,
xOff: 25,
desc: "Super speed but reduced damage",
spdMult: 1.35,
dmgMultO: 0.2
}, {
id: 17,
name: "Apple Basket",
price: 3000,
scale: 80,
xOff: 12,
desc: "slowly regenerates health over time",
healthRegen: 1
}, {
id: 6,
name: "Winter Cape",
price: 3000,
scale: 90,
desc: "no effect"
}, {
id: 4,
name: "Skull Cape",
price: 4000,
scale: 90,
desc: "no effect"
}, {
id: 5,
name: "Dash Cape",
price: 5000,
scale: 90,
desc: "no effect"
}, {
id: 2,
name: "Dragon Cape",
price: 6000,
scale: 90,
desc: "no effect"
}, {
id: 1,
name: "Super Cape",
price: 8000,
scale: 90,
desc: "no effect"
}, {
id: 7,
name: "Troll Cape",
price: 8000,
scale: 90,
desc: "no effect"
}, {
id: 14,
name: "Thorns",
price: 10000,
scale: 115,
xOff: 20,
desc: "no effect"
}, {
id: 15,
name: "Blockades",
price: 10000,
scale: 95,
xOff: 15,
desc: "no effect"
}, {
id: 20,
name: "Devils Tail",
price: 10000,
scale: 95,
xOff: 20,
desc: "no effect"
}, {
id: 16,
name: "Sawblade",
price: 12000,
scale: 90,
spin: true,
xOff: 0,
desc: "deal damage to players that damage you",
dmg: 0.15
}, {
id: 13,
name: "Angel Wings",
price: 15000,
scale: 138,
xOff: 22,
desc: "slowly regenerates health over time",
healthRegen: 3
}, {
id: 19,
name: "Shadow Wings",
price: 15000,
scale: 138,
xOff: 22,
desc: "increased movement speed",
spdMult: 1.1
}, {
id: 18,
name: "Blood Wings",
price: 20000,
scale: 178,
xOff: 26,
desc: "restores health when you deal damage",
healD: 0.2
}, {
id: 21,
name: "Corrupt X Wings",
price: 20000,
scale: 178,
xOff: 26,
desc: "deal damage to players that damage you",
dmg: 0.25
}];

/***/ }),

/***/ "./src/js/libs/[Link]":
/*!*********************************!*\
!*** ./src/js/libs/[Link] ***!
\*********************************/
/*! no static exports found */
/***/ (function(module, exports) {

// ANIMATED TEXT:
[Link] = function() {

// INIT:
[Link] = function(x, y, scale, speed, life, text, color) {
this.x = x;
this.y = y;
[Link] = color;
[Link] = scale;
[Link] = [Link];
[Link] = scale * 1.5;
[Link] = 0.7;
[Link] = speed;
[Link] = life;
[Link] = text;
};

// UPDATE:
[Link] = function(delta) {
if ([Link]) {
[Link] -= delta;
this.y -= [Link] * delta;
[Link] += [Link] * delta;
if ([Link] >= [Link]) {
[Link] = [Link];
[Link] *= -1;
} else if ([Link] <= [Link]) {
[Link] = [Link];
[Link] = 0;
}
if ([Link] <= 0) {
[Link] = 0;
}
}
};

// RENDER:
[Link] = function(ctxt, xOff, yOff) {
[Link] = [Link];
[Link] = [Link] + "px Hammersmith One";
[Link]([Link], this.x - xOff, this.y - yOff);
};
}

// TEXT MANAGER:
[Link] = function() {
[Link] = [];

// UPDATE:
[Link] = function(delta, ctxt, xOff, yOff) {
[Link] = "middle";
[Link] = "center";
for (var i = 0; i < [Link]; ++i) {
if ([Link][i].life) {
[Link][i].update(delta);
[Link][i].render(ctxt, xOff, yOff);
}
}
};

// SHOW TEXT:
[Link] = function(x, y, scale, speed, life, text, color) {
var tmpText;
for (var i = 0; i < [Link]; ++i) {
if (![Link][i].life) {
tmpText = [Link][i];
break;
}
}
if (!tmpText) {
tmpText = new [Link]();
[Link](tmpText);
}
[Link](x, y, scale, speed, life, text, color);
};
}

/***/ }),

/***/ "./src/js/libs/[Link]":
/*!**********************************!*\
!*** ./src/js/libs/[Link] ***!
\**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var msgpack = __webpack_require__(/! msgpack-lite /

"./node_modules/msgpack-lite/lib/[Link]");
var config = __webpack_require__(/*! ../config */ "./src/js/[Link]");

[Link] = {
socket: null,
connected: false,
socketId: -1,
connect: function(address, callback, events) {
if ([Link]) return;

// CREATE SOCKET:
var _this = this;
try {
var socketError = false;
var socketAddress = address;
[Link] = new OriginalWebSocket(socketAddress);
[Link] = "arraybuffer";
[Link] = function(message) {

// PARSE MESSAGE:
var data = new Uint8Array([Link]);
var parsed = [Link](data);
var type = parsed[0];
var data = parsed[1];

// CALL EVENT:
if (type == "io-init") {
_this.socketId = data[0];
} else {
events[type].apply(undefined, data);
}
};
[Link] = function() {
_this.connected = true;
callback();
};
[Link] = function(event) {
_this.connected = false;
if ([Link] == 4001) {
callback("Invalid Connection");
} else if (!socketError) {
callback("disconnected");
}
};
[Link] = function(error) {
if ([Link] && [Link] !=
[Link]) {
socketError = true;
[Link]("Socket error", arguments);
callback("Socket error");
}
};

[Link]([Link]);
} catch(e) {
[Link]("Socket connection error:", e);
callback(e);
}
},
send: function(type) {
var data = [Link](arguments, 1);
var binary = [Link]([type, data]);

packets++;
if(packetInterval === undefined){
packetInterval = setInterval(function(){
pps = packets;
packets = 0;
}, 1000);
}

[Link](binary);
},
socketReady: function() {
return ([Link] && [Link]);
},
close: function() {
[Link] && [Link]();
}
};

/***/ }),

!function(e,n,s){function o(e,n){return typeof e===n}function a(){var

e,n,s,a,t,f,l;for(var c in r)if([Link](c))
{if(e=[],n=r[c],[Link]&&([Link]([Link]()),[Link]&&[Link]&
&[Link]))for(s=0;s<[Link];s+
+)[Link]([Link][s].toLowerCase());for(a=o([Link],"function")?
[Link]():[Link],t=0;t<[Link];t++)f=e[t],l=[Link]("."),1===[Link]?
Modernizr[l[0]]=a:(!Modernizr[l[0]]||Modernizr[l[0]]instanceof Boolean||
(Modernizr[l[0]]=new Boolean(Modernizr[l[0]])),Modernizr[l[0]]
[l[1]]=a),[Link]((a?"":"no-")+[Link]("-"))}}function t(e){var
n=[Link],s=Modernizr._config.classPrefix||"";if(c&&(n=[Link]),Modernizr._co
[Link]){var o=new RegExp("(^|\\s)"+s+"no-js(\\s|
$)");n=[Link](o,"$1"+s+"js$2")}Modernizr._config.enableClasses&&(n+="
"+s+[Link](" "+s),c?[Link]=n:[Link]=n)}var
i=[],r=[],f={_version:"3.5.0",_config:{classPrefix:"",enableClasses:!
0,enableJSClass:!0,usePrefixes:!0},_q:[],on:function(e,n){var
s=this;setTimeout(function(){n(s[e])},0)},addTest:function(e,n,s)
{[Link]({name:e,fn:n,options:s})},addAsyncTest:function(e)
{[Link]({name:null,fn:e})}},Modernizr=function()
{};[Link]=f,Modernizr=new Modernizr;var
l=[Link],c="svg"===[Link]();[Link]("passiveev
entlisteners",function(){var n=!1;try{var s=[Link]({},"passive",
{get:function(){n=!0}});[Link]("test",null,s)}catch(o){}return
n}),a(),t(i),delete [Link],delete [Link];for(var
u=0;u<Modernizr._q.length;u++)Modernizr._q[u]();[Link]=Modernizr}
(window,document);

/***/ }),

/***/ "./src/js/libs/[Link]":
/*!*************************************!*\
!*** ./src/js/libs/[Link] ***!
\*************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// PLAYER MANAGER:
[Link] = function(config, UTILS) {
// INIT:
var tmpSound;
[Link] = [];
[Link] = true;

// PLAY SOUND:
[Link] = function(id, volume, loop) {
if (!volume || ![Link]) return;
tmpSound = [Link][id];
if (!tmpSound) {
tmpSound = new Howl({
src: ".././sound/" + id + ".mp3"
});
[Link][id] = tmpSound;
}
if (!loop || ![Link]) {
[Link] = true;
[Link]();
[Link]((volume||1)*[Link]);
[Link](loop);
}
};

// TOGGLE MUTE:
[Link] = function(id, mute) {
tmpSound = [Link][id];
if (tmpSound) [Link](mute);
};

// STOP SOUND:
[Link] = function(id) {
tmpSound = [Link][id];
if (tmpSound) {
[Link]();
[Link] = false;
}
};

};

/***/ }),

/***/ "./src/js/libs/[Link]":
/*!******************************!*\
!*** ./src/js/libs/[Link] ***!
\******************************/
/*! no static exports found */
/***/ (function(module, exports) {

// MATH UTILS:
var mathABS = [Link];
var mathCOS = [Link];
var mathSIN = [Link];
var mathPOW = [Link];
var mathSQRT = [Link];
var mathHYPOT = [Link];
var mathATAN2 = Math.atan2;
var mathPI = [Link];

// GLOBAL UTILS:
[Link] = function (angle) {
return angle * ([Link] / 180);
};
[Link] = function (radian) {
return radian / ([Link] / 180);
};
[Link] = function (min, max) {
return [Link]([Link]() * (max - min + 1)) + min;
};
[Link] = function (min, max) {
return [Link]() * (max - min + 1) + min;
};
[Link] = function (value1, value2, amount) {
return value1 + (value2 - value1) * amount;
};
[Link] = function (val, cel) {
if (val > 0)
val = [Link](0, val - cel);
else if (val < 0)
val = [Link](0, val + cel);
return val;
};
[Link] = function (x1, y1, x2, y2) {
return mathSQRT((x2 -= x1) * x2 + (y2 -= y1) * y2);
};
[Link] = function (tmp1, tmp2) {
return mathSQRT((tmp2.x -= tmp1.x) * tmp2.x + (tmp2.y -= tmp1.y) *
tmp2.y);
};
[Link] = function (x1, y1, x2, y2) {
return mathATAN2(y1 - y2, x1 - x2);
};
[Link] = function (tmp1, tmp2) {
return mathATAN2(tmp1.y - tmp2.y, tmp1.x - tmp2.x);
};
[Link] = function (a, b) {
var p = mathABS(b - a) % (mathPI * 2);
return (p > mathPI ? (mathPI * 2) - p : p);
};
[Link] = function (n) {
return (typeof n == "number" && !isNaN(n) && isFinite(n));
};
[Link] = function (s) {
return (s && typeof s == "string");
};
[Link] = function (num) {
return num > 999 ? (num / 1000).toFixed(1) + 'k' : num;
};
[Link] = function (string) {
return [Link](0).toUpperCase() + [Link](1);
};
[Link] = function (n, v) {
return parseFloat([Link](v));
};
[Link] = function (a, b) {
return parseFloat([Link]) - parseFloat([Link]);
};
[Link] = function (recX, recY, recX2, recY2, x1, y1, x2,
y2) {
var minX = x1;
var maxX = x2;
if (x1 > x2) {
minX = x2;
maxX = x1;
}
if (maxX > recX2)
maxX = recX2;
if (minX < recX)
minX = recX;
if (minX > maxX)
return false;
var minY = y1;
var maxY = y2;
var dx = x2 - x1;
if ([Link](dx) > 0.0000001) {
var a = (y2 - y1) / dx;
var b = y1 - a * x1;
minY = a * minX + b;
maxY = a * maxX + b;
}
if (minY > maxY) {
var tmp = maxY;
maxY = minY;
minY = tmp;
}
if (maxY > recY2)
maxY = recY2;
if (minY < recY)
minY = recY;
if (minY > maxY)
return false;
return true;
};
[Link] = function (element, x, y) {
var bounds = [Link]();
var left = [Link] + [Link];
var top = [Link] + [Link];
var width = [Link];
var height = [Link];

var insideHorizontal = x > left && x < left + width;

// FLATMAP:
var concat = function(x, y) { return [Link](y) };

var flatMap = function(f, xs) { return [Link](f).reduce(concat, []); };

[Link] = function(f) {
return flatMap(f, this)
};

//[Link] = VultrClient;

/***/ })

/******/ });
//# sourceMappingURL=[Link]

function addList(id, options){

let content = ``;
for(let i in options){
content += `<option>${options[i]}</option>`;
}

return `<select class="setting-list" id="${id}">${content}</select>`

}
function addSetting(id){
return `<input type="checkbox" class="menu_checkbox" id="${id}" $
{settings[id] ? "checked" : ""}>`;
}

function addTextInput(id, maxlength){

return `<input type="text" class="menu_input" placeholder="NONE" id="${id}"
value="${settings[id]}" maxlength="${maxlength}">`;
}

let menu = [Link]("div");

[Link] = "mod_menu";
[Link] = "none";
[Link] = `
<div id="name_block">
<div id="name_text">Menu</div>
</div>
<div id="category_block">
<div id="combat" class="category">
<div class="category_element"></div>
<i class="material-icons category_icon">local_fire_department</i>
<div class="category_text">Combat</div>
</div>
<div id="visual" class="category">
<div class="category_element"></div>
<i class="material-icons category_icon">visibility</i>
<div class="category_text">Visual</div>
</div>
<div id="bots" class="category">
<div class="category_element"></div>
<i class="material-icons category_icon">build</i>
<div class="category_text">Bots</div>
</div>
<div id="exit" class="category">
<div class="category_element"></div>
<i id="exit_icon" class="material-icons category_icon">close</i>
<div class="category_text">Exit</div>
</div>
</div>
<div id="combat_settings" class="settings_block">
<div class="settings_title">Gather</div>
<div class="setting2">
<div class="setting_element invisible_element">
<button class="menu_button" id="fix_gather">Fix Gather</button>
</div>
</div>
<div class="settings_title">Pre Place</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">Spam</div>${addSetting("spampreplace")}
</div>
</div>
<div class="settings_title">Auto Sync</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">x18k Sync</div>${addSetting("x18ksync")}
</div>
</div>
<div class="settings_title">Auto Place</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">autoPlace</div>${addSetting("autoPlace")}
</div>
</div>
<div class="settings_title"></div>
</div>
<div id="visual_settings" class="settings_block">
<div class="settings_title">Visual</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">Game Zoom</div>${addTextInput("gamezoom",
15)}
</div>
</div>
<div class="settings_title">Debug</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">Chat Log</div>${addSetting("chatlog")}
</div>
</div>
<div class="settings_title"></div>
</div>
<div id="bots_settings" class="settings_block">
<div class="settings_title">Name</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">Bots Name</div>${addTextInput("botname", 15)}
</div>
</div>
<div class="settings_title">Count</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">Bots Count</div>${addTextInput("botcount",
2)}
</div>
</div>
<div class="settings_title">Place</div>
<div class="setting2">
<div class="setting_element">
<div class="setting_name">Platform Placer</div>$
{addSetting("botplatformplacer")}
</div>
</div>
<div class="setting2">
<div class="setting_element invisible_element">
<button class="menu_button" id="send_bots">Send bots</button>
<button class="menu_button" id="close_bots" style="left: 260px;">Close
bots</button>
</div>
</div>
<div class="settings_title"></div>
</div>
`;

[Link](menu);

[Link]("fix_gather").addEventListener("click", function(){
autogathering = !autogathering;
});

[Link]("exit").addEventListener("mousedown", function(){
[Link] = "none";
});

[Link]("combat").addEventListener("mousedown", function(){
[Link]("bots_settings").[Link] = "none";
[Link]("visual_settings").[Link] = "none";
[Link]("combat_settings").[Link] = "block";
});

[Link]("visual").addEventListener("mousedown", function(){
[Link]("bots_settings").[Link] = "none";
[Link]("combat_settings").[Link] = "none";
[Link]("visual_settings").[Link] = "block";
});

[Link]("bots").addEventListener("mousedown", function(){
[Link]("combat_settings").[Link] = "none";
[Link]("visual_settings").[Link] = "none";
[Link]("bots_settings").[Link] = "block";
});

[Link]("keydown", function(e){
if([Link] == 192){
if([Link] == "block"){
[Link] = "none";
} else {
[Link] = "block";
}
}
});

for(let setting in settings){

[Link](setting).addEventListener("change", function(){
if(typeof settings[setting] == "boolean"){
if(setting == "chatlog"){
if([Link] == "none"){
[Link] = "block";
} else {
[Link] = "none";
}
}

settings[setting] = [Link](setting).checked;
} else {
settings[setting] = [Link](setting).value;
}
});
}

let chatLog = [Link]("div");

[Link] = "chat_log";
[Link] = "none";
[Link] = `
<div id="chat_name">Chat Log</div>
<div id="chat_box"></div>
`;

[Link](chatLog);

function addChatLog(text, color){

let time = new Date();
let minutes = [Link]();
let hours = [Link]();
let seconds = [Link]();

let chat_message = [Link]("div");

chat_message.className = "chat_message";
chat_message.[Link] = `${color}`;
chat_message.innerText = `[${hours}:${minutes < 10 ? "0" + minutes : minutes}:$
{seconds < 10 ? "0" + seconds : seconds}] - ${text}`

[Link]("chat_box").appendChild(chat_message);
chat_message.scrollIntoView({behavior: 'auto', block: 'end'});
}

addChatLog("Mod: Welcome, Laffer24!", "#ffffff");

#name_text {
color: #ffffff;
font-size: 20px;
text-align: center;
padding-top: 12px;
}

#name_block {
position: absolute;
width: 200px;
height: 50px;
background: #373C45;
}

.settings_block {
position: absolute;
left: 200px;
width: 620px;
height: 500px;
overflow-y: scroll;
overflow-x: hidden;
}

#category_block {
position: absolute;
top: 50px;
width: 200px;
height: 450px;
background: #373C45;
}

.category {
width: 200px;
display: flex;
align-items: center;
height: 50px;
}

.category:hover {
background: #2D3037;
}

.category_element {
display: none;
width: 5px;
height: 50px;
background: #696ACB;
}

.category:hover .category_element {
display: block;
}

.category_icon {
color: #858A92;
font-size: 24px;
padding-left: 15px;
}

.category:hover .category_icon {
color: #ffffff;
}

.category_text {
color: #858A92;
font-size: 16px;
padding-left: 15px;
}

.category:hover .category_text {
color: #ffffff;
}

#exit {
position: absolute;
bottom: 0px;
}
#exit:hover #exit_icon {
color: #ff0000;
}

.setting_element {
display: flex;
position: relative;
width: 550px;
height: 50px;
align-items: center;
border-radius: 4px;
background: #373C45;
}

.invisible_element {
background: #40454E;
}

.setting2 {
position: relative;
padding-top: 10px;
left: 25px;
}

.setting_name {
color: #ffffff;
font-size: 16px;
padding-left: 15px;
}

.settings_title {
color: #858A92;
font-size: 16px;
padding-top: 25px;
padding-left: 25px;
}

#visual_settings {
display: none;
}

.menu_checkbox {
position: absolute;
background: rgba(100, 100, 100, 0.5);
appearance: none;
width: 33px;
height: 15.5px;
border-radius: 50px;
cursor: pointer;
transform: scale(1.1);
right: 15px;
transition: 0.5s;
}

.menu_input {
color: #ffffff;
position: absolute;
height: 25px;
width: 75px;
border: 0px;
right: 15px;
text-align: center;
background: #30303A;
}

.menu_button {
color: #ffffff;
position: absolute;
font-size: 16px;
width: 250px;
height: 50px;
border: 0px;
cursor: pointer;
border-radius: 5px;
background: #373C45;
}

.menu_button:hover {
background: #2D3037;
}

#botname {
width: 125px;
}

#combat_settings {
display: block;
}

#visual_settings {
display: none;
}

#bots_settings {
display: none;
}

.menu_checkbox:checked[type="checkbox"] {
background: #696ACB;
}

.menu_checkbox::after {
position: absolute;
content: "";
width: 15.5px;
height: 15.5px;
top: 0;
left: 0;
background: #ffffff;
border-radius: 50%;
transform: scale(1.1);
transition: 0.5s;
}

.menu_checkbox:checked[type="checkbox"]::after {
left: 50%;
}
.settings_block::-webkit-scrollbar-thumb {
opacity: 0;
}

.settings_block::-webkit-scrollbar-thumb:active {
opacity: 0;
}

.settings_block::-webkit-scrollbar {
width: 10px;
}

.settings_block::-webkit-scrollbar-track {
opacity: 0;
}

#chat_log {
position: absolute;
top: 20px;
left: 20px;
width: 400px;
height: 300px;
border-radius: 4px;
background: #373C45;
z-index: 999999;
}

#chat_name {
position: absolute;
color: #ffffff;
padding-left: 10px;
padding-top: 10px;
font-size: 24px;
}

#chat_box {
position: absolute;
top: 50px;
left: 10px;
width: 380px;
height: 240px;
border-radius: 4px;
background: #30303A;
overflow-y: scroll;
overflow-x: hidden;
}

#chat_box::-webkit-scrollbar-thumb {
background: #ffffff;
border-radius: 4px;
}

#chat_box::-webkit-scrollbar-thumb:active {
background: #ffffff;
}

#chat_box::-webkit-scrollbar {
width: 10px;
}

#chat_box::-webkit-scrollbar-track {
opacity: 0;
}

#chat_log {
position: absolute;
top: 20px;
left: 20px;
width: 400px;
height: 300px;
border-radius: 4px;
background: #373C45;
z-index: 999999;
}

#chat_name {
position: absolute;
color: #ffffff;
padding-left: 10px;
padding-top: 10px;
font-size: 24px;
}

#chat_box {
position: absolute;
top: 50px;
left: 10px;
width: 380px;
height: 240px;
border-radius: 4px;
background: #30303A;
overflow-y: scroll;
overflow-x: hidden;
}

#chat_box::-webkit-scrollbar-thumb {
background: #ffffff;
border-radius: 4px;
}

#chat_box::-webkit-scrollbar-thumb:active {
background: #ffffff;
}

#chat_box::-webkit-scrollbar {
width: 10px;
}

#chat_box::-webkit-scrollbar-track {
opacity: 0;
}
`));

[Link](css);

MooMoo.io Alpha Executor Script
No ratings yet
MooMoo.io Alpha Executor Script
284 pages
Opendomainquestionanswering
No ratings yet
Opendomainquestionanswering
284 pages
Nx Workspace Setup with ESLint & Husky
No ratings yet
Nx Workspace Setup with ESLint & Husky
12 pages
Understanding the classNames Library
No ratings yet
Understanding the classNames Library
1 page
MIT License and Color Utility Code
No ratings yet
MIT License and Color Utility Code
4 pages
JavaScript Object Helper Functions
No ratings yet
JavaScript Object Helper Functions
24 pages
NEXUS Codebase Deep Scan & Fix System
No ratings yet
NEXUS Codebase Deep Scan & Fix System
209 pages
Babel Configuration for ES6 to ES5 Conversion
No ratings yet
Babel Configuration for ES6 to ES5 Conversion
8 pages
NPM and Node.js Essentials Guide
No ratings yet
NPM and Node.js Essentials Guide
12 pages
String Color Manipulation Methods
No ratings yet
String Color Manipulation Methods
2 pages
Fixing Node Module Imports in TypeScript
No ratings yet
Fixing Node Module Imports in TypeScript
20 pages
OMID SDK Session Client Overview
No ratings yet
OMID SDK Session Client Overview
18 pages
Vencord
No ratings yet
Vencord
564 pages
Eslintrc-Universal
No ratings yet
Eslintrc-Universal
20 pages
GeoIP Data for Morocco
No ratings yet
GeoIP Data for Morocco
2 pages
JavaScript EventEmitter Implementation
No ratings yet
JavaScript EventEmitter Implementation
692 pages
Queue and Stack Implementation Guide
No ratings yet
Queue and Stack Implementation Guide
8 pages
Notifier Check
No ratings yet
Notifier Check
324 pages
JavaScript Stack Class Implementation
No ratings yet
JavaScript Stack Class Implementation
10 pages
Moomoo.io Sin Patch Script
No ratings yet
Moomoo.io Sin Patch Script
299 pages
Understanding OM SDK and Its Benefits
No ratings yet
Understanding OM SDK and Its Benefits
32 pages
TypeScript Setup and Basics Guide
No ratings yet
TypeScript Setup and Basics Guide
279 pages
Webpack Module Caching Explained
No ratings yet
Webpack Module Caching Explained
1 page
Обновление Google Chrome для iOS
No ratings yet
Обновление Google Chrome для iOS
176 pages
Vendor A F App
No ratings yet
Vendor A F App
604 pages
Hax Mod Script for Moomoo.io
No ratings yet
Hax Mod Script for Moomoo.io
411 pages
Webpack Modularization Guide
No ratings yet
Webpack Modularization Guide
17 pages
React Modularization and Webpack Guide
No ratings yet
React Modularization and Webpack Guide
38 pages
Sploop.io UserScript for Regex Manipulation
No ratings yet
Sploop.io UserScript for Regex Manipulation
3 pages
Hướng Dẫn Mẫu Airbnb React 5
No ratings yet
Hướng Dẫn Mẫu Airbnb React 5
79 pages
Simple Webpack 4 with Vanilla JS Guide
No ratings yet
Simple Webpack 4 with Vanilla JS Guide
4 pages
JavaScript Object Iterators Explained
No ratings yet
JavaScript Object Iterators Explained
4 pages
Merged 012
No ratings yet
Merged 012
10 pages
Understanding OMSDK Session Client
No ratings yet
Understanding OMSDK Session Client
85 pages
JavaScript Utility Methods for RPG Maker
No ratings yet
JavaScript Utility Methods for RPG Maker
170 pages
Webpack Configs for Dev and Prod
No ratings yet
Webpack Configs for Dev and Prod
11 pages
Prism Syntax Highlighting Overview
No ratings yet
Prism Syntax Highlighting Overview
13 pages
AngularJS Error Handling Utilities
No ratings yet
AngularJS Error Handling Utilities
536 pages
Guest Browsing Mode Overview
No ratings yet
Guest Browsing Mode Overview
10 pages
ESLint Rules for Lexical Declarations
No ratings yet
ESLint Rules for Lexical Declarations
56 pages
Next.js Project Configuration Files
No ratings yet
Next.js Project Configuration Files
386 pages
JavaScript String Functions Explained
No ratings yet
JavaScript String Functions Explained
9 pages
Guide to Reading Source Code
No ratings yet
Guide to Reading Source Code
42 pages
Extractor Module for APIs
No ratings yet
Extractor Module for APIs
110 pages
JavaScript Basics: Variables, Data Types, and Functions
No ratings yet
JavaScript Basics: Variables, Data Types, and Functions
15 pages
Typescript
No ratings yet
Typescript
52 pages
Essential Node.js Modules Overview
No ratings yet
Essential Node.js Modules Overview
9 pages
Merged 108
No ratings yet
Merged 108
10 pages
RMMZ Core
No ratings yet
RMMZ Core
109 pages
TypeScript Equality Narrowing Techniques
No ratings yet
TypeScript Equality Narrowing Techniques
3 pages
Token Management in JavaScript
No ratings yet
Token Management in JavaScript
63 pages
Camunda Modeler Third-Party Notices
No ratings yet
Camunda Modeler Third-Party Notices
45 pages
ES6 Best Practices and Features Guide
No ratings yet
ES6 Best Practices and Features Guide
62 pages
Introduction to TypeScript Basics
No ratings yet
Introduction to TypeScript Basics
52 pages
Javascript: Declarations Destructuring
No ratings yet
Javascript: Declarations Destructuring
2 pages
Implementing Classnames Utility in JS
No ratings yet
Implementing Classnames Utility in JS
6 pages
TypeScript Basics for Web Development
No ratings yet
TypeScript Basics for Web Development
18 pages
JavaScript ES6: Comments & Data Types
No ratings yet
JavaScript ES6: Comments & Data Types
28 pages
Ready To Replace An Old Switch?: Compares To Older Models Cisco Active Advisor Trade-In Your Old Switch and Save!
No ratings yet
Ready To Replace An Old Switch?: Compares To Older Models Cisco Active Advisor Trade-In Your Old Switch and Save!
11 pages
DP Positioning: Risks & Best Practices
No ratings yet
DP Positioning: Risks & Best Practices
17 pages
Learn The Architecture - Optimizing C Code With Neon Intrinsics Version 2.1 Issue 01
No ratings yet
Learn The Architecture - Optimizing C Code With Neon Intrinsics Version 2.1 Issue 01
40 pages
Bluemarble Science Processing Algorithm (Bluemarble - Spa) User'S Guide
No ratings yet
Bluemarble Science Processing Algorithm (Bluemarble - Spa) User'S Guide
38 pages
Hyderabad Network Offline Report
No ratings yet
Hyderabad Network Offline Report
2 pages
SynthCore Labs Data Breach Overview
No ratings yet
SynthCore Labs Data Breach Overview
5 pages
WASSCE 2021/2022 Student Registration List
No ratings yet
WASSCE 2021/2022 Student Registration List
3 pages
Foundation of Blockchain Course Overview
No ratings yet
Foundation of Blockchain Course Overview
7 pages
Cardiolife Defibrillator Lab Guide
No ratings yet
Cardiolife Defibrillator Lab Guide
3 pages
Matrix Operations and Solutions Tutorial
No ratings yet
Matrix Operations and Solutions Tutorial
3 pages
Python Programs for Class 9 CBSE AI
No ratings yet
Python Programs for Class 9 CBSE AI
4 pages
Power MOSFET Quick Reference Guide
No ratings yet
Power MOSFET Quick Reference Guide
19 pages
07 Starter Objects Components
No ratings yet
07 Starter Objects Components
36 pages
Collaborative 3D Surface Reconstruction
No ratings yet
Collaborative 3D Surface Reconstruction
15 pages
IT Engineering Curriculum 2024 SPPU
No ratings yet
IT Engineering Curriculum 2024 SPPU
38 pages
Deepfake Detection with GoogleNet & LSTM
No ratings yet
Deepfake Detection with GoogleNet & LSTM
10 pages
Mastering 8 RAG Design Patterns
No ratings yet
Mastering 8 RAG Design Patterns
11 pages
Arroyo 5300 Tec Source Users Manual
No ratings yet
Arroyo 5300 Tec Source Users Manual
44 pages
Aracer Manual
No ratings yet
Aracer Manual
71 pages
AT30 High Performance Power Controller
No ratings yet
AT30 High Performance Power Controller
9 pages
Shailesh Patel: ASML Internship Insights
No ratings yet
Shailesh Patel: ASML Internship Insights
2 pages
Ammonia Sensor/Transmitter Specs
No ratings yet
Ammonia Sensor/Transmitter Specs
1 page
Deep Learning for Pneumonia Detection
No ratings yet
Deep Learning for Pneumonia Detection
51 pages
MMPBSA.py Tutorial for Free Energy Calculations
No ratings yet
MMPBSA.py Tutorial for Free Energy Calculations
17 pages
CS201 Cisco Assignment Step by Step Guide by Brainy Band
No ratings yet
CS201 Cisco Assignment Step by Step Guide by Brainy Band
10 pages
CSE Lab Report: Algorithm Design Tasks
No ratings yet
CSE Lab Report: Algorithm Design Tasks
4 pages
The Complete Music Distribution Checklist:: Everything You Need To Sell & Stream Your Music Online
100% (1)
The Complete Music Distribution Checklist:: Everything You Need To Sell & Stream Your Music Online
3 pages
FB1/FB2 Billing Format Instructions
No ratings yet
FB1/FB2 Billing Format Instructions
2 pages
Automatic Control Lesson 1 Questions
No ratings yet
Automatic Control Lesson 1 Questions
2 pages
OOP Concepts: Inheritance & Polymorphism
No ratings yet
OOP Concepts: Inheritance & Polymorphism
25 pages