// ==UserScript==

// @name Spectra Client (Hacks Extracted)

// @namespace [Link]
// @version 1.0
// @description All hacks from [Link] with the Spectra Client UI
// @author Jules
// @match *://*/*
// @grant none
// ==/UserScript==

(function() {
'use strict';

//__START__HACK_CODE_FROM_POTTERY009_TXT___________________________________________
___

let Fuxny = {};

let defaultAccent = "#FF0000";

const TITLE = "Midnight__" //-----------------------Title

const changeHealthBar = true // --------------------Change health bar color to

gradient color
const spoofRanksEnabled = true; // -----------------Gives you all ranks (YT,
Super, Developer)
const ATTACK_INTERVAL_MS = 20; // -----------------How fast to hit players with
triggerbot/killAura LOW = BAN
let desiredPotionSlot = 1 //------------------------What slot should potions go
to? Numbers start at zero! 0-9
let spikeSlot = 8 //--------------------------------What slot do spikes
automatically go in? 0-9
let webSlot = 9 //----------------------------------What slot do webs / nets
automatically go in? 0-9

let alreadyConnected = null;

let colyRoom = null;
let sendBytesName = null;
let gameObjects = {};
let injectedBool = false;
let myId = 1
let isInitializing = true;
let clientOptions = null;
let noaParent = null;
let noaKeyInParent = null;
let blinkState = {
enabled: false,
originalSendBytes: null,
queued: [],
interval: 0,
noPacket: false
};

let everEnabled = {};

let wallJumpInterval = null;

let wallJumpRunning = false;
 let lockPlayerWaterStateInterval = null;
let waterJumpingEnabled = false

let wireFramesBool = false;

let espEnabled = false;

let chestESPEnabled = false;

let oreESPEnabled = false;
let chestOreInterval = null;
let chestBoxes = {};

let isSkyboxHidden = false;

let triggerBotEnabled = false;

let toggleTriggerBotInterval = null;

const possibleNames = [
//"LegLeftMesh",
//"LegRightMesh",
//"TorsoNode",
//"ArmLeftMesh",
//"ArmRightMesh",
"BodyMesh",
'Body|Armour',
//"HeadMesh"
]; // Potential detection: If the player has leg armour there is no way
leftLegMesh could have been hit.
let killAuraEnabled = false
let killAuraIntervalId = null
let killshotEnabled = false
let killshotInterval = null
let inventoryCleanerEnabled = false
let inventoryCleanerInterval = null
let lastClosestId = null
let newBox = null;
let newBoxId = null;
let __nullKey = null; //Entity enabled key
let __stringKey = null; //Entity ID key "Then why didn't you just label them
that?"
let animationFrameId = null;
let hitBoxEnabled = false;
const hitboxes = {};

let cachedNameTagParent = null;

let cachedBHOPParent = null;

let autoPotionEnabled = false;

let autoPotionInterval = null;
let nameTagsEnabled = false;
let nameTagsIntervalId = null;
let nameTagParent = null;

let bhopEnabled = false;

let bhopIntervalId = null;

let enemyHealthGuiEnabled = false;

let healthWatcherInterval = null;
let lastPercent = null;
let lastChangeTime = [Link]();
let resetTimeout = null;

let eIdKey = null;

let targetEntity = null;
let targetEntityDistance = null;

let pickupReachEnabled = false; //Credits to wang!!!!

let originalGetEntitiesInAABB = null;
const RANGE_MULTIPLIER = 5;
let ghMethodKey = null;
let proto = null;

let bhopKnifeEnabled = false;

let spaceVid;
let fadeVolumeInterval;
let spaceHeld = false;
let bigHeadsEnabled = false;
let antiBanEnabled = false;

const scannedChunks = new Set();

let chunkDataField = null;

// ETC
let playerKey = null;
let moveState = null;
let physState = null;
let humanoidMeshlist = null;
let playerEntity = null;
let skyboxEntity = null;
let skyboxMesh = null;
let bigHeadsInterval = null;
let scaffoldIntervalId = null;
let targetFinderId = null;
let setHealthBar = null;
let playerInventoryParent = null;

// Variables and helper functions outside the object

let distance = 0.1;
let moveInterval = null;
let lastUpTime = 0;
 var S = {
normalizeVector(t) { let e = t[0] * t[0] + t[1] * t[1] + t[2] * t[2]; if (e
> 0) { let i = 1 / [Link](e); return [t[0] * i, t[1] * i, t[2] * i] } return
t },
distanceBetween(t, e) { let i = e[0] - t[0], o = e[1] - t[1], s = e[2] -
t[2]; return i * i + o * o + s * s },
distanceBetweenSqrt(t, e) { return [Link]([Link](t, e)) },
lerp(t, e, i) { return t + (e - t) * i }
};
var D = {
fakeMouseEvent(t) {
let e = { button: 0, buttons: 1, clientX: [Link]([Link]() *
999 + 1), clientY: [Link]([Link]() * 999 + 1), screenX:
[Link]([Link]() * 999 + 1), screenY: [Link]([Link]() * 999 + 1),
target: [Link]("#noa-container"), type: t, isTrusted: !0, view:
window, bubbles: !0, cancelable: !0, timeStamp: [Link]() };
return [Link] = [Link], e
}
};
var C = {
wpRequire: null, _cachedNoa: null,
get noa() { return this?._cachedNoa || (this._cachedNoa =
[Link]([Link]).find(t => t?.entities)), this._cachedNoa },
init() {
let t = [Link](window), e =
[Link](t).find(s => t[s]?.set?.toString().includes("++")), i = window[e] =
window[e], o = [Link]([Link]() * 9999999 + 1);
[Link]([ [o], {}, s => [Link] = s ]), [Link] =
[Link]([Link]("nonBlocksClient:")).find(s => typeof s == "object")
},
findModule(t) { let e = [Link].m; for (let i in e) { let o = e[i];
if (o && [Link]().includes(t)) return [Link](i) } return null }
}, l = C;
var I = {
getPosition(t) { return [Link](t, "position").position },
get getMoveState() { return [Link]([Link])[36] },
getPhysicsBody(t) { return [Link](t, "physics").body },
get registry() { return [Link]([Link])[17] },
get getBlockSolidity() { return [Link]([Link])[5] },
get getBlockID() { return
[Link][[Link]([Link])
[3]].bind([Link]) },
get getHeldItem() { return [Link]([Link]).find(t => t?.length ==
1 && t?.toString()?.length < 13 && t?.toString().includes(").")) },
safeGetHeldItem(t) { let e; try { e = [Link](t) } catch {} return
e },
get playerList() { return [Link]([Link]()).filter(t =>
t !== 1 && [Link](t)).map(t => parseInt(t)) },
get doAttack() { let t = [Link](1); return (t?.doAttack ||
[Link]).bind(t) },
setVelocity(t = null, e = null, i = null) { let o = [Link](1),
s = [Link](o)[16]; t !== null && (s[0] = t), e !== null && (s[1] = e), i !== null
&& (s[2] = i) },
isAlive(t) { return [Link]([Link])[37](t).isAlive },
touchingWall() { let t = [Link](1), e = .35, i = [ [0, 0, 0], [e,
0, 0], [-e, 0, 0], [0, 0, e], [0, 0, -e], [e, 0, e], [e, 0, -e], [-e, 0, e], [-e,
0, -e] ], o = [0, 1, 2]; for (let [s, c, d] of i) for (let u of o) { let m =
[Link](t[0] + s), h = [Link](t[1] + c + u), E = [Link](t[2] + d), M =
[Link](m, h, E); if ([Link](M)) return !0 } return !1 }
};
var n = { noa: I, mouse: D };

var r = { //WANG
keys(e) {
var t = [],
o = 0;
for (var s in e) e != null && (t[o] = s, o++);
return t
},
values(e) {
for (var t = [Link](e), o = [], s = 0, i = 0; s < [Link];) {
var l = t[s],
d = e[l];
o[i] = d, i++, s++
}
return o
},
assign(e, ...t) {
let o = Object(e);
for (let s = 0; s < [Link]; s++) {
let i = t[s];
if (i != null)
for (let l in i) o[l] = i[l]
}
return o
}
};

function fadeVolume(from, to, duration) {

const steps = 30;
const stepTime = duration / steps;
let current = 0;

if (fadeVolumeInterval) clearInterval(fadeVolumeInterval);

fadeVolumeInterval = setInterval(() => {

current++;
const progress = current / steps;
[Link] = from + (to - from) * progress;

if (current >= steps) {

clearInterval(fadeVolumeInterval);
fadeVolumeInterval = null;
}
}, stepTime * 1000);
}

function onKeyDown(e) {
if ([Link] === 'Space' && !spaceHeld) {
spaceHeld = true;
[Link] = '1';
[Link]();
fadeVolume([Link], 0.1, 2.5); // fade in to 0.8 over 2 seconds
 }
}

function onKeyUp(e) {
if ([Link] === 'Space') {
spaceHeld = false;
[Link] = '0';
fadeVolume([Link], 0.1, 2.5); //
setTimeout(() => {
if (!spaceHeld) [Link]();
}, 500);
}
}

function showTemporaryNotification(message, duration = 1500) {

const defaultBackGroundColor = 'rgba(0, 0, 0, 0.5)'; // semi-transparent
black
const defaultBackGroundBlur = 9;
const defaultAccent = "#FF0000"; // HEX accent color

// Create a notification container if it doesn't exist

let notificationContainer = [Link]('notification-
container');
if (!notificationContainer) {
notificationContainer = [Link]('div');
[Link] = 'notification-container';
[Link] = 'fixed';
[Link] = '20px';
[Link] = '20px';
[Link] = '132';
[Link](notificationContainer);
}

// Create notification element

const notification = [Link]('div');
[Link] = message;

// Style the notification

[Link] = '12px';
[Link] = '#fff';
[Link] = '4px';
[Link] = '0 4px 8px rgba(0, 0, 0, 0.2)';
[Link] = 'opacity 0.5s ease-in-out, transform 0.5s
ease-in-out';
[Link] = '0';
[Link] = 'translateY(20px)';
[Link] = '10px';
[Link] = defaultBackGroundColor;
[Link] = `blur(${defaultBackGroundBlur}px)`;

// Border using accent color

[Link] = `2px solid ${defaultAccent}`;

// Optional: give it a slight gradient inner glow (if you want it fancier)
// [Link] = `0 0 12px ${defaultAccent}, 0 4px 8px
rgba(0,0,0,0.2)`;

// Add to container
 [Link](notification);

// Trigger the fade-in effect

setTimeout(() => {
[Link] = '1';
[Link] = 'translateY(0)';
}, 10);

// Set up the fade-out and removal

setTimeout(() => {
[Link] = '0';
// No translateY(-20px) because you disliked that

setTimeout(() => {
[Link]();
if ([Link] === 0) {
[Link]();
}
}, 500);
}, duration);
}

function clearESPBoxes() {
for (const key in chestBoxes) {
for (const {
mesh,
id
} of chestBoxes[key]) {
[Link]();
[Link](id);
}
}
[Link]();
chestBoxes = {};
}

function reverseIndex(i, stride) {

const x = [Link](i / stride[0]);
const remX = i % stride[0];
const y = [Link](remX / stride[1]);
const z = remX % stride[1];
return [x, y, z];
}

function getChunkKey(chunk) {
const [wx, wy, wz] = [Link] || [0, 0, 0];
const cx = [Link](wx / 32);
const cy = [Link](wy / 32);
const cz = [Link](wz / 32);
return `${cx}|${cy}|${cz}|overworld`;
}

function scanChunk(chunk, blockIDs) {

const blockData = chunk[chunkDataField];
if (!blockData) return;

const {
data,
stride
 } = blockData;

const pos = [Link] || [0, 0, 0];

if (!data || !stride) return;

const chunkKey = getChunkKey(chunk);

for (let i = 0; i < [Link]; i++) {
const blockID = data[i];
if () continue;

const [x, y, z] = reverseIndex(i, stride);

const worldX = pos[0] + x + 0.5;
const worldY = pos[1] + y + 0.5;
const worldZ = pos[2] + z + 0.5;

const mesh = [Link]("espbox", 0.5, false, 1,

[Link]);
[Link](worldX, worldY, worldZ);
[Link] = 1;

[Link] = new [Link]("mat",

[Link])

const id = [Link]([worldX, worldY, worldZ], null, null,

mesh);
if (!chestBoxes[chunkKey]) chestBoxes[chunkKey] = [];
chestBoxes[chunkKey].push({
mesh,
id
});

if ([204, 205, 206, 207].includes(blockID)) {

[Link]("FOUNDCHEST")

[Link] = new [Link].Color3(1, 0.5, 0); //

orange
[Link] = new [Link].Color3(1, 0.5, 0); //
makes it glow orange
}
if (blockID === 45) {
[Link] = new [Link].Color3(0, 0, 1); //
blue
[Link] = new [Link].Color3(0, 0, 1); //
makes it glow blue
}

if (blockID === 465) {

[Link] = new [Link].Color3(0.7, 0.5, 1); //
pale purple
[Link] = new [Link].Color3(0.7, 0.5,
1); // makes it glow pale purple
}
 }
}

function scanAllChunks() {
if (!Fuxny?.world || !Fuxny?.world?.[[Link]]?.hash) return;
const chunkHash = [Link][[Link]].hash;
// Step 1: Remove boxes for chunks no longer loaded
for (const scannedKey of scannedChunks) {
if (!(scannedKey in chestBoxes)) continue;

if (.some(chunk => getChunkKey(chunk) ===

scannedKey)) {
// Delete all meshes for this chunk
for (const {
mesh,
id
} of chestBoxes[scannedKey]) {
[Link](); // remove from scene
[Link](id); // remove from entity system
if needed
}
delete chestBoxes[scannedKey];
[Link](scannedKey);
}
}

// Step 2: Scan newly loaded chunks

for (const chunkKey in chunkHash) {

const chunk = chunkHash[chunkKey];

if (!chunkDataField) {
autoDetectChunkDataField(chunk);
if (!chunkDataField) continue; // Skip if still not found
}

const blockData = chunk[chunkDataField];

if (!blockData?.data || ![Link] || ![Link]) continue;

const key = getChunkKey(chunk);

if ([Link](key)) continue;
[Link](key);
if (chestESPEnabled) scanChunk(chunk, [204, 205, 206, 207]);
if (oreESPEnabled) scanChunk(chunk, [44, 45, 465, 50]);
}
}

function stopMoving() {
if (moveInterval) {
clearInterval(moveInterval);
moveInterval = null;
}
}

function startMoving() {
if (moveInterval) return; // Already moving

moveInterval = setInterval(() => {

 let pos = [Link](1, 'position').position;
let h = [Link];
let p = [Link];

let newX = pos[0];

let newY = pos[1];
let newZ = pos[2];

const now = [Link]();

if (p < -1) {
// Looking up: move up only if 500ms have passed
if (now - lastUpTime >= 500) {
newY += distance + 0.9;
lastUpTime = now;
}
} else if (p > 1) {
// Looking down: move down
newY -= distance;
} else {
// Move forward horizontally
newX += [Link](h) * distance;
newZ += [Link](h) * distance;
}

[Link](1, newX, newY, newZ);

}, 20);
}

function dumpAllFunctions(obj, includePrototype = false) {

const seen = new Set();
let current = obj;
let index = 1;

[Link](`?? Function Dump`);

do {
const props = [Link](current);
for (const key of props) {
if ([Link](key)) continue;
[Link](key);

try {
const val = obj[key];
if (typeof val === "function") {
[Link](`?? [${index++}] ${key}()`);
[Link]([Link]());
[Link]();
}
} catch (e) {
[Link](`?? Could not access function '${key}':`, e);
}
}

current = includePrototype ? [Link](current) : null;

} while (current && current !== [Link]);

[Link]();
 }

function searchForTerm(obj, term) {

const results = [];
const visited = new WeakSet();

function recurse(current, path = []) {

if (typeof current !== 'object' || current === null) return;

if ([Link](current)) return;
[Link](current);

for (const key in current) {

if () continue;

const value = current[key];

const keyMatch = [Link]().includes([Link]());
const valMatch = (
typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean'
) && String(value).toLowerCase().includes([Link]());

if (keyMatch || valMatch) {
[Link]({
path: [...path, key].join('.'),
key: key,
value: value
});
}

if (typeof value === 'object' && value !== null) {

recurse(value, [...path, key]);
}
}
}

recurse(obj);
return results;
}

function matchesAllPatterns(fn) {
const patterns = ["[Link]", ".base[0]"].map(p => [Link](/\
s+/g, ''));
try {
const src = [Link]().replace(/\s+/g, '');
return [Link](p => [Link](p));
} catch {
return false;
}
}

function findClassConstructor(obj) {
let current = obj;
while (current) {
for (const key of [Link](current)) {
let val;
try {
const desc = [Link](current, key);
 val = desc?.value ?? current[key];
} catch {
continue;
}
if (typeof val === "function" && matchesAllPatterns(val)) {
return val;
}
}
current = [Link](current);
}
return null;
}

function findGhMethod(clsConstructor) {
const protoLocal = clsConstructor?.prototype;
if (!protoLocal) return null;

for (const key of [Link](protoLocal)) {

if (key === "constructor") continue;
const fn = protoLocal[key];
if (typeof fn === "function" && matchesAllPatterns(fn)) {
return {
fn,
key
};
}
}
return null;
}

const toggleBlink = (interval = 0, noPacket = false) => {

[Link] = ![Link];
[Link] = interval;
[Link] = noPacket;

if ([Link]) {
[Link](`[Blink] ENABLED � interval: ${interval}, noPacket: $
{noPacket}`);

colyRoom[sendBytesName] = (...args) => {

const [J, T] = args;

const send = () => [Link](colyRoom, J,
T);

if (interval > 0) {
setTimeout(send, interval);
} else {
[Link]([J, T]);
}
};
} else {
[Link](`[Blink] DISABLED � sending ${[Link]}
packets.`);

for (const [J, T] of [Link]) {

[Link](colyRoom, J, T);
}
 colyRoom[sendBytesName] = [Link];
[Link] = [];
}
};

function wangPlace(position) {

let heldBlock = [Link]([Link][[Link]])

[22].list[0]._blockItem;
let worldInstanceKey = [Link](heldBlock)[0];
let worldInstance = [Link](heldBlock)[0];
let targetedBlockKey = [Link](worldInstance)[25];
let targetedBlock = worldInstance[targetedBlockKey];

function spoofTargetedBlock(position) {
return new Proxy({}, {
get(target, prop, receiver) {
if (prop === worldInstanceKey) {
return new Proxy(worldInstance, {
get(inner, key) {
if (key === targetedBlockKey) {
let spoofedTargetedBlock =
structuredClone(targetedBlock) || {};
[Link] = position;
return spoofedTargetedBlock;
}
return worldInstance[key];
},
});
}

if (prop == "checkTargetedBlockCanBePlacedOver") {
return () => true;
}

if (typeof heldBlock[prop] == "function") {

return heldBlock[prop].bind(heldBlock);
} else {
return heldBlock[prop];
}
},
});
}

[Link](spoofTargetedBlock(position));
}

function placeToPlayer(position) {

// Convert to block coordinates by flooring each component

const blockX = [Link](position[0]);
const blockY = [Link](position[1]);
const blockZ = [Link](position[2]);
if ([Link]([blockX, blockY - 3,
blockZ]) || [Link]([Link])[47].call([Link], blockX, blockY - 3, blockZ)
=== 0) {
wangPlace([blockX, blockY - 3, blockZ])
}
if ([Link]([blockX, blockY - 2,
blockZ]) || [Link]([Link])[47].call([Link], blockX, blockY - 2, blockZ)
=== 0) {
wangPlace([blockX, blockY - 2, blockZ])
}
if ([Link]([blockX, blockY - 1,
blockZ]) || [Link]([Link])[47].call([Link], blockX, blockY - 1, blockZ)
=== 0) {
wangPlace([blockX, blockY - 1, blockZ])
}
if ([Link]([blockX, blockY,
blockZ]) || [Link]([Link])[47].call([Link], blockX, blockY, blockZ) ===
0) {
wangPlace([blockX, blockY, blockZ])
}

function placeSpike(position) {

// Convert to block coordinates by flooring each component

const blockX = [Link](position[0]);
const blockY = [Link](position[1]);
const blockZ = [Link](position[2]);
if ([Link]([blockX, blockY + 1,
blockZ]) || [Link]([Link])[47].call([Link], blockX, blockY + 1, blockZ)
=== 0) {
wangPlace([blockX, blockY + 1, blockZ])
}
}

function moveItem(itemName, desiredSlot) {

if (!playerInventoryParent || !
[Link]?.items) {
[Link]("? playerInventoryParent is not set. Run
findAndSavePlayerInventoryParent() first.");
return false;
}
const items = [Link];
let oldSlot = null;
for (let i = 0; i < [Link]; i++) {
const item = items[i];

if (!item || typeof [Link] !== 'string') continue;

const name = [Link]();
if ([Link](itemName)) {

oldSlot = i;
break;
}
}
if (oldSlot === null) {
[Link](`? No ${itemName} found in slot 10 or higher.`);
return false;
}
[Link](`?? Swapping ${itemName} from slot ${oldSlot} with slot $
{desiredSlot}`);
[Link](oldSlot, desiredSlot, null);
return true;
 }

function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}

function bunnyHop() {
if (![Link]?.() || [Link] || [Link] <
0.05) return;
[Link] = true;
physState._hadJumpInputPrevTick = false;
setTimeout(() => {
[Link] = false;
}, 20);
}

function waitForElement(selector, callback) {

if (alreadyConnected) {
[Link] = false;
[Link] = "Click if game loaded."
startWebSocketWatcher();
return;
}
const observer = new MutationObserver((mutations) => {
for (const mutation of mutations) {
for (const node of [Link]) {
if ([Link] === 1 && [Link](selector)) {
[Link]();
callback(node);
return;
}
}
}
});

[Link]([Link], {
childList: true,
subtree: true
});
}

async function autoSW() {

if (lastClosestId && targetEntityDistance <= 36) { // place web then spikes

if (moveItem("net", webSlot) || moveItem("web", webSlot)) {

let enemyPos = [Link](lastClosestId,
'position').position;

[Link]['_events'][`HotBarSlot${webSlot + 1}`]();

placeToPlayer(enemyPos);

await sleep(50); // delay before switching to spikes

if (moveItem("spikes", spikeSlot)) {
[Link]['_events'][`HotBarSlot${spikeSlot + 1}`]
();
placeSpike(enemyPos);
}
 } else { // just place spikes
if (moveItem("spikes", spikeSlot)) {
[Link]['_events'][`HotBarSlot${spikeSlot + 1}`]
();
await sleep(50);

let enemyPos = [Link](lastClosestId,

'position').position;
placeToPlayer(enemyPos);
} else {
[Link]("no spikes or webs!");
}
}
[Link]['_events'].HotBarSlot1();
} else {
[Link]("No target or too far");
}
if (![Link]) {
[Link] = true
};
}

function distBetween(a, b) {
return [Link](
(b[0]-a[0])**2 +
(b[1]-a[1])**2 +
(b[2]-a[2])**2
);
}
function normVector(v) {
const len = [Link](v[0]**2 + v[1]**2 + v[2]**2);
return len > 0 ? [v[0]/len, v[1]/len, v[2]/len] : [0,0,0];
}
function shootAtEnemies() {
if (!playerEntity || ![Link] || ![Link]) return;
const myPos = [Link](1, "position").[Link]();
myPos[1] += 1.6;
if ([Link]._gunItem.[Link] !== "Gun" ||
[Link]._gunItem.reloading) return;
for (const key in [Link]) {
if (key === "1") continue;
const entityData = [Link]?.[1]?.[key];
if (!entityData || !entityData._isAlive || ![Link])
continue;
if ([Link][1][key]?.lobbyLeaderboardValues?.team) {if
([Link][1][key].[Link] === [Link][1]
[1].[Link]) continue;}
if ([Link][1][key]?.lobbyLeaderboardValues?.teamDisplay) {if
([Link][1][key].[Link] ===
[Link][1][1].[Link]) continue;}
const enemyPos = [Link](key, "position")?.position;
if (!enemyPos) continue;
const targetPos = [enemyPos[0], enemyPos[1]+1.6, enemyPos[2]];
const vector = normVector([
targetPos[0]-myPos[0],
targetPos[1]-myPos[1],
targetPos[2]-myPos[2]
]);
const gun = [Link]._gunItem;
 const losCheck = [Link](new Float32Array(vector), 0);
if ([Link] !== "HeadMesh") continue;
const originalFunc =
[Link];
[Link] = () => new
Float32Array(vector);
[Link]();
[Link] = originalFunc;
}
}

function distBetween(a, b) {
return [Link](
(b[0]-a[0])**2 +
(b[1]-a[1])**2 +
(b[2]-a[2])**2
);
}
function normVector(v) {
const len = [Link](v[0]**2 + v[1]**2 + v[2]**2);
return len > 0 ? [v[0]/len, v[1]/len, v[2]/len] : [0,0,0];
}
function shootAtEnemies() {
if (!playerEntity || ![Link] || ![Link]) return;
const myPos = [Link](1, "position").[Link]();
myPos[1] += 1.6;
if ([Link]._gunItem.[Link] !== "Gun" ||
[Link]._gunItem.reloading) return;
for (const key in [Link]) {
if (key === "1") continue;
const entityData = [Link]?.[1]?.[key];
if (!entityData || !entityData._isAlive || ![Link]) continue;
if ([Link][1][key]?.lobbyLeaderboardValues?.team) {if
([Link][1][key].[Link] === [Link][1]
[1].[Link]) continue;}
if ([Link][1][key]?.lobbyLeaderboardValues?.teamDisplay) {if
([Link][1][key].[Link] ===
[Link][1][1].[Link]) continue;}
const enemyPos = [Link](key, "position")?.position;
if (!enemyPos) continue;
const targetPos = [enemyPos[0], enemyPos[1]+1.6, enemyPos[2]];
const vector = normVector([
targetPos[0]-myPos[0],
targetPos[1]-myPos[1],
targetPos[2]-myPos[2]
]);
const gun = [Link]._gunItem;
const losCheck = [Link](new Float32Array(vector), 0);
if ([Link] !== "HeadMesh") continue;
const originalFunc = [Link];
[Link] = () => new
Float32Array(vector);
[Link]();
[Link] = originalFunc;
}
}

const materialRank = {
"Wood": 0,
 "Stone": 1,
"Iron": 2,
"Gold": 3,
"Diamond": 4,
"Knight": 5
};

function getMaterialRankForItem(item) {
if (!item || ![Link]) return -1;
const mat = [Link](materialRank).find(m => [Link](m));
return mat ? materialRank[mat] : -1;
}

function cleanInventory() {
if (!playerInventoryParent || ![Link]) return;

const inv = [Link];

const items = [Link];

function findIndices(predicate) {
const result = [];
for (let i = 0; i <= 45; i++) {
const it = items[i];
if (it && predicate(it, i)) [Link](i);
}
return result;
}

const dropNames = ["Seeds", "Sapling", "Mushroom", "Empty Bottle"];

for (let i = 0; i <= 45; i++) {
const item = items[i];
if (!item) continue;
if ([Link](name => [Link](name))) {
[Link](i, [Link], true);
}
}

const armorTypes = {
"Helmet": 46,
"Chestplate": 47,
"Gauntlets": 48,
"Leggings": 49,
"Boots": 50
};

for (let i = 0; i <= 45; i++) {

const item = items[i];
if (!item) continue;
const type = [Link](armorTypes).find(t => [Link](t));
if (!type) continue;
const material = [Link](materialRank).find(m =>
[Link](m));
if (!material) continue;
const targetSlot = armorTypes[type];
const currentArmorItem = items[targetSlot];
if (!currentArmorItem) {
[Link](i, targetSlot);
} else {
const currentMat = [Link](materialRank).find(m =>
[Link](m));
const currentRank = currentMat ? materialRank[currentMat] : -1;
if (materialRank[material] > currentRank) {
[Link](i, targetSlot);
} else {
[Link](i, 1, true);
}
}
}

const swordIndices = findIndices(it => [Link]("Sword"));

let bestSwordIdx = -1;
let bestSwordRank = -1;
for (const idx of swordIndices) {
const rank = getMaterialRankForItem(items[idx]);
if (rank > bestSwordRank) {
bestSwordRank = rank;
bestSwordIdx = idx;
}
}
if (bestSwordIdx !== -1) {
const hot0 = items[0];
if (!hot0) {
if (bestSwordIdx !== 0)
[Link](bestSwordIdx, 0);
} else {
if ([Link]("Sword")) {
const hot0Rank = getMaterialRankForItem(hot0);
if (bestSwordRank > hot0Rank) {
[Link](bestSwordIdx, 0);
}
} else {
[Link](bestSwordIdx, 0);
}
}
bestSwordIdx = 0;
}
for (const idx of swordIndices) {
if (idx === bestSwordIdx) continue;
const it = items[idx];
if (!it || ![Link]("Sword")) continue;
[Link](idx, [Link], true);
}

const bowIndices = findIndices(it => [Link]("Bow"));

let bestBowIdx = -1;
let bestBowRank = -1;
for (const idx of bowIndices) {
const rank = getMaterialRankForItem(items[idx]);
if (rank > bestBowRank) {
bestBowRank = rank;
bestBowIdx = idx;
}
}
if (bestBowIdx !== -1) {
const hot1 = items[1];
if (!hot1) {
if (bestBowIdx !== 1) [Link](bestBowIdx,
1);
 } else {
if ([Link]("Bow")) {
const hot1Rank = getMaterialRankForItem(hot1);
if (bestBowRank > hot1Rank) {
[Link](bestBowIdx, 1);
}
} else {
[Link](bestBowIdx, 1);
}
}
bestBowIdx = 1;
}
for (const idx of bowIndices) {
if (idx === bestBowIdx) continue;
const it = items[idx];
if (!it || ![Link]("Bow")) continue;
[Link](idx, [Link], true);
}

for (let h = 0; h <= 9; h++) {

const hotItem = items[h];
if (!hotItem) continue;
if ([Link]("Arrow")) {
let freeSlot = -1;
for (let s = 10; s <= 45; s++) {
if (!items[s]) {
freeSlot = s;
break;
}
}
if (freeSlot !== -1) {
[Link](h, freeSlot);
}
}
}

const pickIndices = findIndices(it => [Link]("Pickaxe"));

let bestPickIdx = -1;
let bestPickRank = -1;
for (const idx of pickIndices) {
const rank = getMaterialRankForItem(items[idx]);
if (rank > bestPickRank) {
bestPickRank = rank;
bestPickIdx = idx;
}
}
if (bestPickIdx !== -1) {
const hot2 = items[2];
if (!hot2) {
if (bestPickIdx !== 2) [Link](bestPickIdx,
2);
} else {
if ([Link]("Pickaxe")) {
const hot2Rank = getMaterialRankForItem(hot2);
if (bestPickRank > hot2Rank) {
[Link](bestPickIdx, 2);
}
} else {
[Link](bestPickIdx, 2);
 }
}
bestPickIdx = 2;
}
for (const idx of pickIndices) {
if (idx === bestPickIdx) continue;
const it = items[idx];
if (!it || ![Link]("Pickaxe")) continue;
[Link](idx, [Link], true);
}

const blockNames = ["Wood Planks", "Messy Stone"];

for (const name of blockNames) {
const indices = findIndices(it => [Link](name) && [Link] &&
[Link]);
if ([Link] <= 1) continue;
let target = indices[0];
for (let k = 1; k < [Link]; k++) {
const src = indices[k];
const srcItem = items[src];
if (!srcItem) continue;
try {
[Link](target, target + 1,
src, [Link]);
} catch (e) {
[Link](src, target);
}
}
}
let bestBlockSlot = -1;
let bestBlockAmount = -1;
for (let i = 0; i <= 45; i++) {
const it = items[i];
if (!it) continue;
if ([Link](name => [Link](name))) {
if ([Link] > bestBlockAmount && [Link] !== bestBlockAmount) {
bestBlockAmount = [Link];
bestBlockSlot = i;
}
}
}
if (bestBlockSlot !== -1) {
const hot9 = items[9];
if (!hot9) {
if (bestBlockSlot !== 9)
[Link](bestBlockSlot, 9);
} else {
[Link](bestBlockSlot, 9);
}
}

{
const snowIndices = findIndices(it => [Link]("Snowball") &&
[Link] && [Link]);
if ([Link] > 0) {
const target = snowIndices[0];
for (let k = 1; k < [Link]; k++) {
const src = snowIndices[k];
if (!items[src]) continue;
 try {
[Link](target, target +
1, src, items[src].amount);
} catch (e) {
[Link](src, target);
}
}
const hot3 = items[3];
if (!hot3) {
if (target !== 3) [Link](target, 3);
} else {
[Link](target, 3);
}
}
}

{
const breadIndices = findIndices(it => [Link]("Bread") &&
[Link] && [Link]);
if ([Link] > 0) {
const target = breadIndices[0];
for (let k = 1; k < [Link]; k++) {
const src = breadIndices[k];
if (!items[src]) continue;
try {
[Link](target, target +
1, src, items[src].amount);
} catch (e) {
[Link](src, target);
}
}
const hot8 = items[8];
if (!hot8) {
if (target !== 8) [Link](target, 8);
} else {
[Link](target, 8);
}
}
}
}

function triggerXPDuper() {
if (!injectedBool) {
showTemporaryNotification("? Inject first!");
return;
}
try {
const sendPacketModule = [Link]("push({message");
const sendPacket = [Link](sendPacketModule).find(fn =>
fn?.toString().includes("[Link]("));

if (!sendPacket) {
showTemporaryNotification("? Could not find sendPacket function.");
return;
}

const inventory = [Link](1, "inventory").inventory;

if (!inventory) {
showTemporaryNotification("? Could not find inventory.");
 return;
}

sendPacket(20, {
"zy": inventory._selectedSlotI,
"xy": 0
});

[Link]({
"name": "Aura XP Fragment",
"typeObj": [Link]("Aura XP Fragment"),
"amount": 4,
"attributes": {}
});

showTemporaryNotification("? XP Duper triggered!");

} catch (error) {
[Link]("[XPDuper] Error:", error);
showTemporaryNotification("? XP Duper failed. See console.");
}
}

function makeHitboxes() {
if (!injectedBool || ![Link]) return;

const rendering = [Link]([Link])[18];

if (!rendering) return;

const playerIds = [Link];

if (!playerIds) return;

const activeEIds = new Set(playerIds);

// Create hitboxes for new players

for (const playerId of playerIds) {
if (hitboxes[playerId]) continue; // Skip if hitbox already exists

let newBox_00 = [Link]("hitbox_mesh_" + playerId, 1,

false, 1, [Link]);
newBox_00.renderingGroupId = 2;

newBox_00.material = new [Link]("mat",

[Link]);
newBox_00.[Link] = new [Link].Color3(1, 1, 1);
newBox_00.[Link] = new [Link].Color3(1, 1, 1);
newBox_00.name = '_hitbox';
newBox_00.id = '__hitbox_' + playerId;

let defaultPosition = new newBox_00.[Link](0, 0.32, 0);

newBox_00.position = [Link]();
newBox_00._scaling._y = 2.2;
newBox_00.[Link] = 0.5;
newBox_00.isVisible = hitBoxEnabled;

const transformNodeKey = [Link]();

[Link](newBox_00, transformNodeKey, 13);
[Link]([Link])[27].call([Link], newBox_00);
 [Link](newBox_00._nodeDataStorage, '_isEnabled', {
get: () => true,
set: (v) => {},
configurable: false
});

hitboxes[playerId] = newBox_00;
}

// Cleanup hitboxes for players who have left

for (const eId in hitboxes) {
if ()) {
hitboxes[eId]?.dispose();
delete hitboxes[eId];
}
}

// Toggle visibility for all active hitboxes

for (const eId in hitboxes) {
if (hitboxes[eId]) {
hitboxes[eId].isVisible = hitBoxEnabled;
}
}
}

function startHealthWatcher() {
if (healthWatcherInterval) clearInterval(healthWatcherInterval);

healthWatcherInterval = setInterval(() => {

if (!injectedBool || !lastClosestId) {
setHealthBar(100, false); // Hide bar if no target
return;
}

const state = [Link](lastClosestId,

"genericLifeformState");
if (!state || ![Link]) {
setHealthBar(100, false);
return;
}

// This is an assumption based on common game engine patterns.

// The old method was obfuscated and has broken.
const health = [Link];
const maxHealth = [Link];

if (typeof health === 'number' && typeof maxHealth === 'number' &&
maxHealth > 0) {
const percent = (health / maxHealth) * 100;
setHealthBar(percent, true);
} else {
setHealthBar(100, false);
}

}, 300);
}

(() => {
// Remove if already present
 const old = [Link]("vertical-health-bar");
if (old) [Link]();

// Create bar container

const container = [Link]("div");
[Link] = "vertical-health-bar";
[Link]([Link], {
position: "fixed",
left: "calc(50% - 200px)", // 100px left of center
top: "50%",
transform: "translateY(-50%)",
width: "4px",
height: "200px",
background: "#000",
border: "2px solid black",
zIndex: 120,
pointerEvents: "none",
display: "flex",
alignItems: "flex-end",
overflow: "hidden"
});

// Create fill element

const fill = [Link]("div");
[Link]([Link], {
width: "100%",
height: "100%",
background: "limegreen",
transform: "scaleY(1)",
transformOrigin: "bottom",
transition: "transform 0.2s ease, background 0.2s ease", // <-- add
comma here
});

[Link](fill);
[Link](container);

// Function to compute smooth gradient color from green ? red

function getHealthColor(health) {
const ratio = health / 100;

if (ratio > 0.5) {

// Bright green ? orange
const t = (ratio - 0.5) * 2;
const r = [Link](255 * (1 - t));
const g = 255;
return `rgb(${r}, ${g}, 0)`; // green to yellow to orange
} else {
// Orange ? red
const t = ratio * 2;
const r = 255;
const g = [Link](255 * t);
return `rgb(${r}, ${g}, 0)`; // orange to red
}
}

// Global health setter and show/hide toggle

setHealthBar = function(health, show = true) {
 const clamped = [Link](0, [Link](health, 100));
[Link] = `scaleY(${clamped / 100})`;
[Link] = getHealthColor(clamped);
[Link] = show ? "flex" : "none";
};
setHealthBar(100, false)
})();

function performInjection() {
[Link]();
function inject() {
let winDescriptors = [Link](window);
let wpName = [Link](winDescriptors).find(key =>
winDescriptors[key]?.set?.toString().includes("++"));
let wpInstance = window[wpName] = window[wpName];

// HILOCATOR push
[Link]([
[[Link]([Link]() * 90000) + 10000], {},
function(wpRequire) {
[Link] = (code) => wpRequire([Link](wpRequire.m)
[[Link](wpRequire.m).findIndex(m => [Link]().includes(code))]);
[Link] =
[Link]([Link]("nonBlocksClient:")).find(prop => typeof prop ==
"object");
[Link] = [Link]([Link]).find(prop =>
prop?.entities);
//Credits to, you guessed it wang!
}
]);

const targetValue = [Link]([Link])[2];

const entityEntries = [Link]([Link]);
[Link] = [Link](([_, val]) => val === targetValue)?.
[0];
[Link] = [Link]([Link])[17]
[Link] = [Link]([Link])[12]
[Link] = [Link];

[Link] = [Link]([Link])[19]

if ([Link]) {
[Link]("importantList identified:", [Link]);

// Attempt to find BHOP references

const key = [Link];
if (key) {
const entity = [Link]?.[key];
if (entity?.moveState?.list?.[0] && entity?.movement?.list?.
[0]) {
playerKey = key;
moveState = [Link][0];
physState = [Link][0];
cachedBHOPParent = entity;
[Link]("? Cached BHOP entity data");
} else {
 [Link]("?? Found key but missing BHOP components");
}
} else {
[Link]("? BHOP player key not found");
}
}

function findeIdKey() {

const rendering = [Link]([Link])[18];

const objectData = rendering?.objectData;
if (!objectData) return;

const sample = objectData[1];

for (const key in sample) {
if (sample[key] === 1) {
eIdKey = key;
break;
}
}
}

findeIdKey();

let mesh = [Link]([Link])[7].meshes[0];

let scene = [Link]([Link])[7];
let engine = [Link]();
let StandardMaterial = [Link];
let Color3 = [Link];
let sceneLoaderMod =
[Link]("getEngine().displayLoadingUI()");
const addKey = [Link]([Link])[10]
const addComponent = [Link][addKey];
[Link] = [Link]([Link])[11]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]([Link])[29]
[Link] = {
scene,
engine,
InstancedMesh: [Link],
Mesh: [Link],
Scene: [Link],
Engine: [Link],
sceneLoader: [Link](sceneLoaderMod).find(mod => typeof
[Link] === "function"),
Color3,
StandardMaterial,
addComponent,
addKey
};
playerInventoryParent =
[Link][[Link]].[Link][0].opWrapper

function autoDetectChunkDataField(chunk) {
for (const key of [Link](chunk)) {
const val = chunk[key];
if (!val) continue;
 if (
typeof val === "object" &&
[Link]([Link]) &&
[Link] === 3 &&
(
[Link]([Link]) ||
[Link]([Link]) // covers Uint16Array etc.
)
) {
[Link]("? Detected chunk data field:", key);
chunkDataField = key;
return key;
}
}

[Link]("? Failed to auto-detect chunk data field");

return null;
}

autoDetectChunkDataField([Link]([Link][[Link]].hash)
[0]);

const maybeEntity = [Link]([Link]([Link][[Link]])

[22].list[0])[1];

const hasDoAttackDirect = typeof maybeEntity?.doAttack === 'function';

const hasDoAttackBreakingItem = typeof
maybeEntity?.breakingItem?.doAttack === 'function';

if (hasDoAttackDirect) {
[Link]("maybeEntity has doAttack");
playerEntity = maybeEntity;
} else if (hasDoAttackBreakingItem) {
[Link]("[Link] has doAttack");
playerEntity = [Link];
} else {
[Link]("Neither maybeEntity nor its breakingItem has
doAttack");
playerEntity = null;
}

function findOnlysendBytes(obj) {
if (!obj) {
[Link]("? Provided object is null or undefined.");
return null;
}

const proto = [Link](obj);

const props = [Link](proto);

for (const key of props) {

if (key === 'constructor') continue;

const val = proto[key];

if (typeof val === 'function') {
const str = [Link]();
 // Looser but effective pattern detection
const looksLikesendBytes =
[Link] === 2 &&
/Protocol\.ROOM_DATA_BYTES/[Link](str) &&
[Link]('Uint8Array') &&
/typeof/.test(str) && // just check any typeof usage
[Link]('.encode') &&
([Link]('.byteLength') ||
[Link]('.length')) &&
[Link]('.set');

if (looksLikesendBytes) {
[Link](`? Real sendBytes found: ${key}`);
return key;
}
}
}

[Link]("? sendBytes function not found.");

return null;
}

// Usage
colyRoom = [Link]([Link])[0];
sendBytesName = findOnlysendBytes(colyRoom);

if (!colyRoom || typeof colyRoom[sendBytesName] !== "function") {

[Link]("[Blink] colyRoom or sendBytes not ready.");
}

blinkState = {
enabled: false,
originalSendBytes: colyRoom[sendBytesName],
queued: [],
interval: 0,
noPacket: false
};

cachedNameTagParent = [Link]

injectedBool = true;
}

function setupKillAuraBox() {

newBox = [Link]("mesh", 1, false, 1,

[Link]);
[Link] = 1;
newBoxId = [Link]([0, 10, 0], null, null, newBox);

//[Link] = true;
[Link] = new [Link]("mat",
[Link]);
[Link] = new [Link].Color3(1, 1, 1);
 [Link] = new [Link].Color3(1, 1, 1);
[Link] = 'BodyMesh';
[Link] = 'BodyMesh';
[Link] = false;

// Find null key

__nullKey = null;
for (const key in newBox) {
if ([Link] === 2 && newBox[key] === null) {
__nullKey = key;
break;
}
}
if (__nullKey) {
newBox[__nullKey] = false;
}

[Link] = [Link]([Link])[30]

humanoidMeshlist = [Link][[Link]]?.humanoidMesh?.list;
__stringKey = null;
if ([Link](humanoidMeshlist)) {
outerLoop: for (const obj of humanoidMeshlist) {
for (const key in obj) {
if (typeof obj[key] === "string") {
__stringKey = key;
break outerLoop;
}
}
}
} else {
[Link]("? Invalid humanoidMeshlist path.");
}

// Follow loop
function followHeadLoop() {
if (newBox) {
const playerId = 1;
const playerPosState = [Link](playerId,
"position");

if (playerPosState && [Link]([Link])) {

const [x, y, z] = [Link];
const newPos = [x, y + 1.5, z];
[Link](newBoxId, newPos);
} else {
[Link]("Player position not found or invalid");
}
}

animationFrameId = requestAnimationFrame(followHeadLoop);
}

// Start the loop

animationFrameId = requestAnimationFrame(followHeadLoop);
}

function startTargetFinder() {
if (targetFinderId) clearInterval(targetFinderId);
 targetFinderId = setInterval(() => {
if (!injectedBool || ![Link]) return;

if (![Link](myId,
"genericLifeformState")?.isAlive) {
lastClosestId = null;
return;
}

const myPos = [Link](myId, 'position')?.position;

if (!myPos) return;

const playerIds = [Link];

if (!playerIds) return;

let closestId = null;

let minDist = 100; // Max distance squared (10 blocks)

for (const playerId of playerIds) {

const pos = [Link](playerId,
'position')?.position;
if (!pos) continue;

const state = [Link](playerId,

"genericLifeformState");
if (!state || ![Link]) continue;

const dist = [Link](myPos, pos);

if (dist < minDist) {
minDist = dist;
closestId = playerId;
}
}

if (lastClosestId !== closestId) {

if (hitboxes[lastClosestId]) { // Revert old target color
hitboxes[lastClosestId].[Link] = new
[Link].Color3(1, 1, 1);
hitboxes[lastClosestId].[Link] = new
[Link].Color3(1, 1, 1);
}
if (hitboxes[closestId]) { // Highlight new target
hitboxes[closestId].[Link] = new
[Link].Color3(1, 0, 0);
hitboxes[closestId].[Link] = new
[Link].Color3(1, 0, 0);
}
}

lastClosestId = closestId;

}, 200);
}
inject();
setupKillAuraBox();
startTargetFinder();
setInterval(makeHitboxes, 1000);
}
 waitForElement('[Link]', (el) => {
[Link]('Target div appeared:', el);
performInjection();
if (!injectedBool) {
showTemporaryNotification("injection failed");
} else {
showTemporaryNotification("injection successful");
}
});

//__END__HACK_CODE_FROM_POTTERY009_TXT_____________________________________________
___

// --- ICONS (Lucide style SVGs) ---

const icons = {
main: `<svg xmlns="[Link] width="18" height="18"
fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"><path d="M12
2v20M2 12h20"/></svg>`,
visuals: `<svg xmlns="[Link] width="18" height="18"
fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"><circle
cx="12" cy="12" r="9"/><path d="M12 3v9h9"/></svg>`,
experimental: `<svg xmlns="[Link] width="18"
height="18" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24
24"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>`,
settings: `<svg xmlns="[Link] width="18" height="18"
fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"><circle
cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1-
2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-4
0v-.09a1.65 1.65 0 0 0-1-1.51 1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-
2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1 0-
4h.09a1.65 1.65 0 0 0 1.51-1 1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-
2.83l.06.06c.46.46 1.14.61 1.82.33h.01a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 4 0v.09c0
.66.39 1.25 1 [Link] 1.36.13 1.82-.33l.06-.06a2 2 0 1 1 2.83
2.83l-.06.06c-.46.46-.61 1.14-.33 [Link].85 1 1.51 1H21a2 2 0 0 1 0 4h-.09c-.66
0-1.25.39-1.51 1z"/></svg>`
};

// --- STYLES ---

const style = [Link]("style");
[Link] = `
/* Background */
body::before {
content: "";
position: fixed;
top: 0; left: 0;
width: 100%; height: 100%;
background: radial-gradient(circle at center, #000 0%, #0a0a0f 100%);
background-image:
url("[Link]
z-index: -1;
}

/* Main container */
#spectra-ui {
--primary-color: #D30000;
--secondary-color: #3e0000;
 --text-color: #ffffff;
--bg-color: rgba(15, 15, 20, 0.92);
--border-color: rgba(255, 255, 255, 0.1);
--hover-bg-color: rgba(255, 255, 255, 0.15);
--font-family: "Segoe UI", sans-serif;

position: fixed;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
width: 520px;
max-width: 95%;
height: 320px;
background: linear-gradient(135deg, var(--primary-color), var(--
secondary-color));
border-radius: 14px;
border: 1px solid var(--border-color);
display: flex;
overflow: hidden;
color: var(--text-color);
font-family: var(--font-family);
box-shadow: 0 0 25px var(--primary-color);
z-index: 999999;
transition: background 0.5s, box-shadow 0.5s, color 0.5s, font-family
0.5s;
}
#spectra-ui * {
font-family: var(--font-family);
}

/* UI Controls */
#spectra-exit-btn {
position: absolute;
top: 8px;
right: 12px;
font-size: 20px;
color: var(--text-color);
opacity: 0.7;
cursor: pointer;
transition: opacity 0.2s;
z-index: 10;
}
#spectra-exit-btn:hover {
opacity: 1;
}
#spectra-reopen-btn {
position: fixed;
top: 20px;
left: 20px;
width: 40px;
height: 40px;
background: var(--bg-color);
border: 1px solid var(--border-color);
border-radius: 8px;
display: none; /* Hidden by default */
justify-content: center;
align-items: center;
font-size: 24px;
color: var(--text-color);
 cursor: pointer;
z-index: 1000000;
box-shadow: 0 0 15px rgba(0,0,0,0.5);
}

/* Sidebar */
#spectra-sidebar {
width: 150px;
background: var(--bg-color);
border-right: 1px solid var(--border-color);
display: flex;
flex-direction: column;
align-items: stretch;
padding: 12px 0;
}

/* Logo blend */
#spectra-sidebar .logo-wrap {
display: flex;
justify-content: center;
align-items: center;
padding: 8px 0 16px;
margin-bottom: 12px;
border-bottom: 1px solid var(--border-color);
}
#spectra-sidebar img {
width: 65px;
border-radius: 10px;
}

/* Tabs with icons */

.spectra-tab {
padding: 10px 14px;
margin: 4px 8px;
border-radius: 8px;
cursor: pointer;
font-size: 14px;
display: flex;
align-items: center;
gap: 8px;
color: var(--text-color);
opacity: 0.8;
transition: background 0.2s, color 0.2s, opacity 0.2s;
}
.spectra-tab svg {
flex-shrink: 0;
}
.spectra-tab span {
flex: 1;
}
.spectra-tab:hover {
background: var(--hover-bg-color);
opacity: 1;
}
.[Link] {
background: linear-gradient(90deg, var(--primary-color), transparent);
color: var(--text-color);
font-weight: 600;
opacity: 1;
}

/* Content area */
#spectra-content {
flex: 1;
background: var(--bg-color);
padding: 16px;
overflow-y: auto;
}
.spectra-category-title {
font-size: 15px;
font-weight: bold;
margin-bottom: 10px;
border-bottom: 1px solid var(--border-color);
padding-bottom: 4px;
color: var(--primary-color);
}

/* Generic UI elements */
.spectra-toggle, .spectra-button, .spectra-setting {
display: flex;
justify-content: space-between;
align-items: center;
background: rgba(255,255,255,0.04);
padding: 8px 12px;
margin: 5px 0;
border-radius: 8px;
transition: background 0.2s;
}
.spectra-toggle:hover, .spectra-button:hover, .spectra-setting:hover {
background: var(--hover-bg-color);
}
.spectra-button {
color: var(--text-color);
font-size: 14px;
border: 1px solid var(--border-color);
cursor: pointer;
text-align: center;
width: 100%;
}

.spectra-toggle label, .spectra-setting label {

font-size: 14px;
}
.spectra-toggle input[type="checkbox"] {
appearance: none;
width: 34px;
height: 18px;
background: #444;
border-radius: 20px;
position: relative;
cursor: pointer;
transition: 0.3s;
}
.spectra-toggle input[type="checkbox"]:checked {
background: var(--primary-color);
}
.spectra-toggle input[type="checkbox"]::before {
content: "";
 position: absolute;
top: 2px; left: 2px;
width: 14px; height: 14px;
background: black;
border-radius: 50%;
transition: 0.3s;
}
.spectra-toggle input[type="checkbox"]:checked::before {
left: 18px;
background: #fff;
}

.hidden { display: none; }

`;
[Link](style);

// --- UI ---
const ui = [Link]("div");
[Link] = "spectra-ui";
[Link] = `
<div id="spectra-exit-btn">?</div>
<div id="spectra-sidebar">
<div class="logo-wrap">
<img src="[Link]
[Link]" alt="Spectra Logo">
</div>
<div class="spectra-tab active" data-tab="main">$
{[Link]}<span>Main</span></div>
<div class="spectra-tab" data-tab="visuals">$
{[Link]}<span>Visuals</span></div>
<div class="spectra-tab" data-tab="experimental">$
{[Link]}<span>Experimental</span></div>
<div class="spectra-tab" data-tab="settings">$
{[Link]}<span>Settings</span></div>
</div>
<div id="spectra-content">
<div class="spectra-category" data-tab-content="main">
<div class="spectra-category-title">Main</div>
<div class="spectra-toggle"><label>Killaura</label><input
type="checkbox" id="hack-killaura"></div>
<div class="spectra-toggle"><label>Killshot</label><input
type="checkbox" id="hack-killshot"></div>
<div class="spectra-toggle"><label>Spider</label><input
type="checkbox" id="hack-spider"></div>
<div class="spectra-toggle"><label>Jesus</label><input
type="checkbox" id="hack-jesus"></div>
<div class="spectra-toggle"><label>BHOP</label><input
type="checkbox" id="hack-bhop"></div>
<div class="spectra-toggle"><label>Scaffold</label><input
type="checkbox" id="hack-scaffold"></div>
<div class="spectra-toggle"><label>Walljump</label><input
type="checkbox" id="hack-walljump"></div>
<div class="spectra-toggle"><label>Waterjump</label><input
type="checkbox" id="hack-waterjump"></div>
<div class="spectra-toggle"><label>Noclip Move</label><input
type="checkbox" id="hack-noclip-move"></div>
<div class="spectra-toggle"><label>Kill Softly</label><input
type="checkbox" id="hack-kill-softly"></div>
<div class="spectra-toggle"><label>BHOP Knife</label><input
type="checkbox" id="hack-bhop-knife"></div>
<button class="spectra-button" id="hack-auto-sw">Auto SW</button>
<button class="spectra-button" id="hack-noclip-place">Noclip
Place</button>
<button class="spectra-button" id="hack-high-jump">High
Jump</button>
<button class="spectra-button" id="hack-xp-duper">XP Duper</button>
</div>

<div class="spectra-category hidden" data-tab-content="visuals">

<div class="spectra-category-title">Visuals</div>
<div class="spectra-toggle"><label>ESP</label><input
type="checkbox" id="hack-esp"></div>
<div class="spectra-toggle"><label>Chest ESP</label><input
type="checkbox" id="hack-chest-esp"></div>
<div class="spectra-toggle"><label>Ore ESP</label><input
type="checkbox" id="hack-ore-esp"></div>
<div class="spectra-toggle"><label>Hitboxes</label><input
type="checkbox" id="hack-hitboxes"></div>
<div class="spectra-toggle"><label>Nametags</label><input
type="checkbox" id="hack-nametags"></div>
<div class="spectra-toggle"><label>Enemy Health</label><input
type="checkbox" id="hack-enemy-health"></div>
<div class="spectra-toggle"><label>Night</label><input
type="checkbox" id="hack-night"></div>
<div class="spectra-toggle"><label>Bigheads</label><input
type="checkbox" id="hack-bigheads"></div>
</div>

<div class="spectra-category hidden" data-tab-content="experimental">

<div class="spectra-category-title">Experimental</div>
<div class="spectra-toggle"><label>Blink</label><input
type="checkbox" id="hack-blink"></div>
<div class="spectra-toggle"><label>Pickup Reach</label><input
type="checkbox" id="hack-pickup-reach"></div>
<div class="spectra-toggle"><label>Anti-Spike</label><input
type="checkbox" id="hack-anti-spike"></div>
<button class="spectra-button" id="hack-spawn-teleport">/spawn
Teleport</button>
<button class="spectra-button" id="hack-anti-web">Anti-Web</button>
</div>

<div class="spectra-category hidden" data-tab-content="settings">

<div class="spectra-category-title">Settings</div>
<div class="spectra-toggle"><label>Anti-Ban (Safer)</label><input
type="checkbox" id="hack-anti-ban"></div>
<div class="spectra-toggle"><label>Inventory Cleaner</label><input
type="checkbox" id="hack-inv-cleaner"></div>
<div class="spectra-category-title">Theme Settings</div>
<div class="spectra-setting">
<label>Primary Color</label>
<input type="color" id="theme-primary-color" value="#D30000">
</div>
<div class="spectra-setting">
<label>Secondary Color</label>
<input type="color" id="theme-secondary-color" value="#3e0000">
</div>
<div class="spectra-setting">
<label>Font</label>
 <select id="theme-font-select">
<option value='"Segoe UI", sans-serif'>Segoe UI</option>
<option value="Arial, sans-serif">Arial</option>
<option value="Verdana, sans-serif">Verdana</option>
<option value="Georgia, serif">Georgia</option>
<option value="'Courier New', monospace">Courier
New</option>
</select>
</div>
<button class="spectra-button" id="theme-reset">Reset
Theme</button>
<button class="spectra-button" id="hack-ranks">Spoof Ranks</button>
<button class="spectra-button" id="hack-player-coords">Show Player
Coords</button>
<button class="spectra-button" id="hack-purge-cookies">Purge
Cookies & Reload</button>
<button class="spectra-button" id="hack-discord">Discord</button>
<button class="spectra-button" id="hack-unban">Attempt Unban
(Reload)</button>
<button class="spectra-button" id="hack-manual-inject">Manual
Inject</button>
</div>
</div>
`;
[Link](ui);

// --- THEME CUSTOMIZATION ---

const uiElement = [Link]('spectra-ui');
const primaryColorPicker = [Link]('theme-primary-color');
const secondaryColorPicker = [Link]('theme-secondary-color');
const fontSelect = [Link]('theme-font-select');
const themeResetBtn = [Link]('theme-reset');

const defaultTheme = {
primary: '#D30000',
secondary: '#3e0000',
font: '"Segoe UI", sans-serif'
};

function applyTheme(primary, secondary, font) {

[Link]('--primary-color', primary);
[Link]('--secondary-color', secondary);
[Link]('--font-family', font);
}

function saveTheme(primary, secondary, font) {

[Link]('spectraTheme', [Link]({ primary, secondary,
font }));
}

function loadTheme() {
const savedTheme = [Link]([Link]('spectraTheme'));
const theme = { ...defaultTheme, ...savedTheme };

applyTheme([Link], [Link], [Link]);

[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
 }

[Link]('input', () =>
applyTheme([Link], [Link],
[Link]));
[Link]('input', () =>
applyTheme([Link], [Link],
[Link]));
[Link]('change', () =>
applyTheme([Link], [Link],
[Link]));

[Link]('change', () =>
saveTheme([Link], [Link], [Link]));
[Link]('change', () =>
saveTheme([Link], [Link], [Link]));
[Link]('change', () => saveTheme([Link],
[Link], [Link]));

[Link]('click', () => {
[Link]('spectraTheme');
loadTheme();
showTemporaryNotification("Theme reset to default.");
});

const reopenBtn = [Link]("div");

[Link] = "spectra-reopen-btn";
[Link] = '?';
[Link](reopenBtn);

// --- Sidebar logic ---

const tabs = [Link](".spectra-tab");
const contents = [Link]("[data-tab-content]");

[Link]((tab) => {
[Link]("click", () => {
[Link]((t) => [Link]("active"));
[Link]("active");

const target = [Link]("data-tab");

[Link]((c) => {
[Link]("hidden");
if ([Link]("data-tab-content") === target) {
[Link]("hidden");
}
});
});
});

// --- UI Controls Logic ---

const exitBtn = [Link]("spectra-exit-btn");
const mainUI = [Link]("spectra-ui");

if (exitBtn && reopenBtn && mainUI) {

// Event to hide the main UI and show the reopen button
[Link]("click", () => {
[Link] = "none";
[Link] = "flex"; // Use 'flex' to center the icon
});
 // Event to show the main UI and hide the reopen button
[Link]("click", () => {
[Link] = "none";
[Link] = "flex"; // Restore original display property
});
}

// --- NEW HACK MODULES ---

class Module {
constructor(name) { [Link] = name; [Link] = false; }
onEnable() {}
onDisable() {}
enable() { [Link] = true; [Link](); }
disable() { [Link] = false; [Link](); }
toggle() { [Link] ? [Link]() : [Link](); }
}

class AntiSpike extends Module {

constructor() { super("AntiSpike"); }
onEnable() {
let items = [Link]([Link]([Link]("Gun:class")).find(o =>
typeof o == "object"));
let registryKey = [Link]([Link])[12];
[Link](o => [Link]("Spikes")).forEach(o =>
{ [Link][registryKey][[Link]] = true; });
}
onDisable() {
let items = [Link]([Link]([Link]("Gun:class")).find(o =>
typeof o == "object"));
let registryKey = [Link]([Link])[12];
[Link](o => [Link]("Spikes")).forEach(o =>
{ [Link][registryKey][[Link]] = false; });
}
}

class Spider extends Module {

constructor() { super("Spider"); }
onRender() {
if ([Link] && [Link]()) {
[Link](null, 5, null);
}
}
}

class Killaura extends Module {

constructor() {
super("Killaura");
[Link] = 0;
[Link] = 100;
}
onRender() {
let now = [Link]();
if (now - [Link] >= [Link]) {
[Link] = now;
[Link]();
}
}
tryKill() {
 let myPos = [Link](1);
const killRadius = antiBanEnabled ? 4.5 : 7;
[Link](playerId => {
let enemyPos = [Link](playerId);
if (enemyPos && [Link](myPos, enemyPos) <=
killRadius) {
let vector = [Link]([enemyPos[0] - myPos[0],
enemyPos[1] - myPos[1], enemyPos[2] - myPos[2]]);
[Link](vector, [Link](), "BodyMesh");
[Link](1)?.trySwingBlock?.();
[Link](1)?.setArmsAreSwinging?.();
}
});
}
}

class Jesus extends Module {

constructor() { super("Jesus"); }
onEnable() {
let items = [Link]([Link]([Link]("Gun:class")).find(o =>
typeof o == "object"));
let registryKey = [Link]([Link])[12];
[Link][registryKey][[Link](o => [Link] == "Water").id] =
true;
[Link][registryKey][[Link](o => [Link] == "Lava").id] =
true;
}
onDisable() {
let items = [Link]([Link]([Link]("Gun:class")).find(o =>
typeof o == "object"));
let registryKey = [Link]([Link])[12];
[Link][registryKey][[Link](o => [Link] == "Water").id] =
false;
[Link][registryKey][[Link](o => [Link] == "Lava").id] =
false;
}
}

class Unban extends Module {

constructor() { super("Unban"); }
onEnable() {
[Link](";").forEach(function(c) { [Link] =
[Link](/^ +/, "").replace(/=.*/, "=;expires=" + new Date().toUTCString() +
";path=/"); });
[Link]();
}
}

class HighJump extends Module {

constructor() { super("HighJump"); }
onEnable() {
[Link](null, 40, null);
}
}

const newHacks = {
antiSpike: new AntiSpike(),
spider: new Spider(),
killaura: new Killaura(),
 jesus: new Jesus(),
unban: new Unban(),
highJump: new HighJump()
};

// --- HACK LOGIC & WIRING ---

function setupHackEventListeners() {
// Helper function to ensure injection before activation
const preCheck = (featureName, checkboxElement) => {
if (!injectedBool) {
showTemporaryNotification(`? Inject first to use ${featureName}!`);
if (checkboxElement) [Link] = false;
return false;
}
return true;
};

// --- Abstraction for Toggles/Buttons ---

const setupRenderToggle = (id, module) => {
[Link](id)?.addEventListener('change', e => {
if (!preCheck([Link], [Link])) return;
[Link] = [Link];
if ([Link]) {
if ([Link]) [Link]();
if ([Link] && )
[Link](module);
} else {
if ([Link]) [Link]();
const index = [Link](module);
if (index > -1) [Link](index, 1);
}
showTemporaryNotification(`${[Link]} ${[Link] ?
'enabled' : 'disabled'}`);
});
};

const setupSimpleToggle = (id, module) => {

[Link](id)?.addEventListener('change', e => {
if (!preCheck([Link], [Link])) return;
[Link]();
showTemporaryNotification(`${[Link]} ${[Link] ?
'enabled' : 'disabled'}`);
});
};

const setupButton = (id, module) => {

[Link](id)?.addEventListener('click', () => {
if (!preCheck([Link])) return;
[Link]();
showTemporaryNotification(`${[Link]} triggered`);
});
};

// --- Wire up New Hacks ---

[Link]('hack-killshot')?.addEventListener('change', e => {
if (!preCheck("Killshot", [Link])) return;
killshotEnabled = [Link];
if (killshotEnabled) {
killshotInterval = setInterval(shootAtEnemies, 50);
 showTemporaryNotification("Killshot ENABLED");
} else {
if (killshotInterval) clearInterval(killshotInterval);
killshotInterval = null;
showTemporaryNotification("Killshot DISABLED");
}
});
setupRenderToggle('hack-killaura', [Link]);
setupRenderToggle('hack-spider', [Link]);
setupSimpleToggle('hack-jesus', [Link]);
setupSimpleToggle('hack-anti-spike', [Link]);
setupButton('hack-high-jump', [Link]);
setupButton('hack-unban', [Link]);

// --- Wire up Old Hacks ---

// Note: The old "Kill Aura" is replaced by the new one.
[Link]('hack-bhop')?.addEventListener('change', e => {
if (!preCheck("BHOP", [Link])) return;
if ([Link]) {
bhopIntervalId = setInterval(bunnyHop, 10);
showTemporaryNotification("BHOP enabled");
} else {
clearInterval(bhopIntervalId);
bhopIntervalId = null;
showTemporaryNotification("BHOP disabled");
}
});

[Link]('hack-scaffold')?.addEventListener('change', e => {
if (!preCheck("Scaffold", [Link])) return;
if ([Link]) {
scaffoldIntervalId = setInterval(() => {
const pos = [Link](1, 'position').position;
if (!pos || !playerEntity ||
[Link] !== "CubeBlock") return;
const exactX = pos[0], exactZ = pos[2];
const blockX = [Link](exactX), blockY = [Link](pos[1]),
blockZ = [Link](exactZ);
const checkPlace = (x, y, z) =>
([Link]([x, y, z]) || [Link]([Link])
[47].call([Link], x, y, z) === 0);
if (checkPlace(blockX, blockY - 1, blockZ))
{ wangPlace([blockX, blockY - 1, blockZ]); return; }
const dx = exactX - blockX, dz = exactZ - blockZ;
const offsets = [];
if (dx < 0.3) [Link]([-1, 0]); if (dx > 0.7)
[Link]([1, 0]);
if (dz < 0.3) [Link]([0, -1]); if (dz > 0.7)
[Link]([0, 1]);
for (const [ox, oz] of offsets) {
const nx = blockX + ox, nz = blockZ + oz;
if (checkPlace(nx, blockY - 1, nz)) { wangPlace([nx, blockY
- 1, nz]); return; }
}
}, 50);
showTemporaryNotification("Scaffold enabled");
} else {
clearInterval(scaffoldIntervalId);
scaffoldIntervalId = null;
 showTemporaryNotification("Scaffold disabled");
}
});

[Link]('hack-walljump')?.addEventListener('change', e => {
if (!preCheck("Walljump", [Link])) return;
const client = Fuxny?.clientOptions, body = Fuxny?.physics?.bodies?.
[0];
if (!client || !body) return;
if ([Link]) {
[Link](client, "airJumpCount", { get: () => { if (!
[Link]) return 0; const [rx, , rz] = [Link]; return (rx === 1 || rx ===
-1 || rz === 1 || rz === -1) ? 999 : 0; }, set(_) {}, configurable: true });
showTemporaryNotification("Walljump enabled");
} else {
[Link](client, "airJumpCount", { value: 0, writable:
true, configurable: true });
showTemporaryNotification("Walljump disabled");
}
});

[Link]('hack-waterjump')?.addEventListener('change', e =>
{
if (!preCheck("Waterjump", [Link])) return;
const c = Fuxny?.entities?.[[Link]]?.movement?.list?.[0];
if (!c) return;
if([Link]) {
try {
[Link](c, "inAirFromWater", { get: () => false,
set: () => {}, configurable: true });
[Link](c, "_jumpCount", { get: () => 0, set: ()
=> {}, configurable: true });
[Link](c, "_ticksOutOfWater", { get: () => 346,
set: () => {}, configurable: true });
[Link](c, "isOnIce", { get: () => true, set: ()
=> {}, configurable: true });
showTemporaryNotification("Waterjump enabled");
} catch (err) { [Link]("Error enabling waterjump:", err); }
} else {
try {
[Link](c, "inAirFromWater", { value: false,
writable: true, configurable: true });
[Link](c, "_jumpCount", { value: 0, writable:
true, configurable: true });
[Link](c, "_ticksOutOfWater", { value: 0,
writable: true, configurable: true });
[Link](c, "isOnIce", { value: false, writable:
true, configurable: true });
showTemporaryNotification("Waterjump disabled");
} catch (err) { [Link]("Error disabling waterjump:", err); }
}
});

[Link]('hack-noclip-move')?.addEventListener('change', e
=> {
if (!preCheck("Noclip Move", [Link])) return;
if ([Link]) { startMoving();
showTemporaryNotification("Noclip Move enabled"); }
else { stopMoving(); showTemporaryNotification("Noclip Move disabled");
}
});

[Link]('hack-kill-softly')?.addEventListener('change', e
=> {
if (!preCheck("Kill Softly", [Link])) return;
if ([Link]) { [Link] =
1500; showTemporaryNotification("Kill Softly enabled"); }
else { [Link] = 200;
showTemporaryNotification("Kill Softly disabled"); }
});

[Link]('hack-bhop-knife')?.addEventListener('change', e =>
{
if (!preCheck("BHOP Knife", [Link])) return;
if ([Link]) {
bhopKnifeEnabled = true;
spaceVid = [Link]('video');
[Link] = '[Link]
[Link] = 'auto'; [Link] = true; [Link] =
false; [Link] = 0; [Link] = 1; [Link] = true;
[Link]([Link], { position: 'fixed', top: '50%',
left: '50%', width: '100vw', height: '100vh', objectFit: 'cover', transform:
'translate(-50%, -50%) scaleX(1.4)', zIndex: 21, pointerEvents: 'none', opacity:
'0', transition: 'opacity 2.5s ease', });
[Link](spaceVid);
[Link]('keydown', onKeyDown);
[Link]('keyup', onKeyUp);
showTemporaryNotification("BHOP Knife enabled");
} else {
bhopKnifeEnabled = false;
[Link]('keydown', onKeyDown);
[Link]('keyup', onKeyUp);
if (spaceVid) { [Link](); if ([Link])
[Link](spaceVid); spaceVid = null; }
spaceHeld = false;
if (fadeVolumeInterval) clearInterval(fadeVolumeInterval);
showTemporaryNotification("BHOP Knife disabled");
}
});

[Link]('hack-auto-sw')?.addEventListener('click', () =>
{ if (preCheck("Auto SW")) autoSW(); });
[Link]('hack-xp-duper')?.addEventListener('click', () => {
triggerXPDuper(); });
[Link]('hack-noclip-place')?.addEventListener('click', ()
=> {
if (!preCheck("Noclip Place")) return;
let pos = [Link](1, 'position').position;
[Link](1, pos[0], pos[1], pos[2] + 1);
let playerEntity = [Link]([Link][[Link]])[22].list[0];
playerEntity._blockItem.placeBlock();
});

// --- Visuals ---

[Link]('hack-esp')?.addEventListener('change', e => {
if (!preCheck("ESP", [Link])) return;
espEnabled = [Link];
const groupId = espEnabled ? 2 : 0;
 if ([Link]([Link]([Link])[18].thinMeshes)) {
for (const thinMesh of [Link]([Link])[18].thinMeshes) {
if (thinMesh?.mesh && typeof [Link] ===
"number") {
[Link] = groupId;
}
}
}
showTemporaryNotification(`ESP ${espEnabled ? 'enabled' :
'disabled'}`);
});

[Link]('hack-chest-esp')?.addEventListener('change', e =>
{
if (!preCheck("Chest ESP", [Link])) return;
chestESPEnabled = [Link];
if (chestESPEnabled || oreESPEnabled) {
if (!chestOreInterval) { chestOreInterval =
setInterval(scanAllChunks, 5000); }
scanAllChunks();
} else {
if (chestOreInterval) { clearInterval(chestOreInterval);
chestOreInterval = null; }
clearESPBoxes();
}
showTemporaryNotification(`Chest ESP ${chestESPEnabled ? 'enabled' :
'disabled'}`);
});

[Link]('hack-ore-esp')?.addEventListener('change', e => {
if (!preCheck("Ore ESP", [Link])) return;
oreESPEnabled = [Link];
if (chestESPEnabled || oreESPEnabled) {
if (!chestOreInterval) { chestOreInterval =
setInterval(scanAllChunks, 5000); }
scanAllChunks();
} else {
if (chestOreInterval) { clearInterval(chestOreInterval);
chestOreInterval = null; }
clearESPBoxes();
}
showTemporaryNotification(`Ore ESP ${oreESPEnabled ? 'enabled' :
'disabled'}`);
});

[Link]('hack-hitboxes')?.addEventListener('change', e => {
if (!preCheck("Hitboxes", [Link])) return;
hitBoxEnabled = [Link];
for (const eId in hitboxes) {
const box = hitboxes[eId];
if (box) [Link] = hitBoxEnabled;
}
showTemporaryNotification(`Hitboxes ${hitBoxEnabled ? 'enabled' :
'disabled'}`);
});

[Link]('hack-nametags')?.addEventListener('change', e => {
if (!preCheck("Nametags", [Link])) return;
if ([Link]) {
 nameTagsEnabled = true;
if (!cachedNameTagParent) { nameTagsEnabled = false; return; }
nameTagParent = cachedNameTagParent;
nameTagsIntervalId = setInterval(() => {
const entityList = [Link];
if (!entityList) return;
for (const subGroup of [Link](entityList)) {
if (!subGroup) continue;
for (const obj of [Link](subGroup)) {
if (obj?.lobbyLeaderboardValues) {
try {
[Link](obj,
'hasPriorityNametag', { get: () => true, set(v){}, configurable: true });
[Link](obj, 'canSee', { get: ()
=> true, set(v){}, configurable: true });
} catch (e) {}
}
}
}
for (const key in nameTagParent) {
const tag = nameTagParent;
if (tag && typeof tag === 'object' &&
[Link]?.includes('NameTag')) {
try {
[Link](tag, '_isVisible', { get: ()
=> true, set(v){}, configurable: true });
[Link](tag, 'renderingGroupId',
{ get: () => 3, set(v){}, configurable: true });
} catch (e) {}
}
}
}, 15000);
showTemporaryNotification("Nametags enabled");
} else {
nameTagsEnabled = false;
clearInterval(nameTagsIntervalId);
nameTagsIntervalId = null;
if (nameTagParent) {
for (const key in nameTagParent) {
const tag = nameTagParent[key];
if (tag && typeof tag === 'object' &&
[Link]?.includes('NameTag')) {
try {
const current = tag._isVisible;
delete tag._isVisible;
tag._isVisible = current;
} catch (e) {}
}
}
}
nameTagParent = null;
showTemporaryNotification("Nametags disabled");
}
});

[Link]('hack-enemy-health')?.addEventListener('change', e
=> {
if (!preCheck("Enemy Health", [Link])) return;
if ([Link]) {
 startHealthWatcher();
showTemporaryNotification("Enemy Health enabled");
} else {
if (healthWatcherInterval) clearInterval(healthWatcherInterval);
if (resetTimeout) clearTimeout(resetTimeout);
setHealthBar(100, false);
lastPercent = null;
showTemporaryNotification("Enemy Health disabled");
}
});

[Link]('hack-night')?.addEventListener('change', e => {
if (!preCheck("Night", [Link])) return;
if([Link]) {
if(!skyboxMesh) {
for (let i = 0; i < 10000; i++) {
const meshState = [Link](i, "mesh");
if (meshState?.mesh?.id === "skyBox") {
skyboxEntity = i; skyboxMesh = [Link]; break;
}
}
}
if(skyboxMesh) [Link] = false;
showTemporaryNotification("Night enabled");
} else {
if(skyboxMesh) [Link] = true;
showTemporaryNotification("Night disabled");
}
});

[Link]('hack-bigheads')?.addEventListener('change', e => {
if (!preCheck("Bigheads", [Link])) return;
const objectData = [Link]([Link])[18].objectData;
if ([Link]) {
for (let key in objectData) {
let obj = objectData[key];
if (obj?.type === "Player" && [Link]?.[16] && obj !==
objectData[1]) {
let node = [Link][16];
[Link]._x = 6; [Link]._y = 6; [Link]._z = 6;
[Link]._y = -1;
}
}
bigHeadsInterval = setInterval(() => {
for (let key in objectData) {
let obj = objectData[key];
if (obj?.type === "Player" && [Link]?.[16] && obj !==
objectData[1]) {
let node = [Link][16];
if ([Link]._x === 1) {
[Link]._x = 6; [Link]._y = 6; [Link]._z
= 6;
[Link]._y = -1;
}
}
}
}, 10000);
showTemporaryNotification("Bigheads enabled");
} else {
 for (let key in objectData) {
let obj = objectData[key];
if (obj?.type === "Player" && [Link]?.[16] && obj !==
objectData[1]) {
let node = [Link][16];
[Link]._x = 1; [Link]._y = 1; [Link]._z = 1;
[Link]._y = 0.7199999690055847;
}
}
clearInterval(bigHeadsInterval);
bigHeadsInterval = null;
showTemporaryNotification("Bigheads disabled");
}
});

// --- Experimental ---

[Link]('hack-blink')?.addEventListener('change', e => {
if (!preCheck("Blink", [Link])) return;
toggleBlink();
showTemporaryNotification(`Blink ${[Link] ? 'enabled' :
'disabled'}`);
});

[Link]('hack-pickup-reach')?.addEventListener('change', e
=> {
if (!preCheck("Pickup Reach", [Link])) return;
if ([Link]) {
if (!proto || !originalGetEntitiesInAABB) {
const cls = findClassConstructor([Link]);
if (!cls) { [Link]("[pickupReach] Could not find class
constructor"); return; }
const ghMethod = findGhMethod(cls);
if (!ghMethod) { [Link]("[pickupReach] Could not find
getEntitiesInAABB method"); return; }
proto = [Link];
originalGetEntitiesInAABB = [Link];
ghMethodKey = [Link];
}
proto[ghMethodKey] = function(box, name) {
const center = [([Link][0] + [Link][0]) / 2, ([Link][1] +
[Link][1]) / 2, ([Link][2] + [Link][2]) / 2];
const halfSize = [([Link][0] - [Link][0]) / 2, ([Link][1] -
[Link][1]) / 2, ([Link][2] - [Link][2]) / 2];
const enlarged = { base: [Link]((c, i) => c - halfSize[i] *
RANGE_MULTIPLIER), max: [Link]((c, i) => c + halfSize[i] * RANGE_MULTIPLIER) };
return [Link](this, enlarged, name);
};
pickupReachEnabled = true;
showTemporaryNotification("Pickup Reach enabled");
} else {
if(proto && ghMethodKey) proto[ghMethodKey] =
originalGetEntitiesInAABB;
pickupReachEnabled = false;
showTemporaryNotification("Pickup Reach disabled");
}
});

[Link]('hack-spawn-teleport')?.addEventListener('click',
() => {
 if (!preCheck("Spawn Teleport")) return;
function findElementByText(text) {
const all = [Link]('div, span, button, a');
for (const el of all) if ([Link]() === text) return
el;
return null;
}
const teleportButtonText = findElementByText('Teleport To Lobby
Spawn');
if (teleportButtonText) {
let clickable = teleportButtonText;
while (clickable && ![Link] && [Link] !==
'BUTTON') clickable = [Link];
if (clickable) [Link]();
else [Link]();
showTemporaryNotification("Teleporting to spawn...");
} else showTemporaryNotification("Teleport button not found.");
});

[Link]('hack-anti-web')?.addEventListener('click', () => {
if (!preCheck("Anti-Web")) return;

[Link]([Link][[Link]].[Link][0].speedMultiplie
[Link], "inCobweb", { configurable: true, enumerable: true, get() { return
1; }, set(value) {} });
showTemporaryNotification("Anti-Web applied");
});

// --- Settings ---

[Link]('hack-anti-ban')?.addEventListener('change', e => {
antiBanEnabled = [Link];
showTemporaryNotification(`Anti-Ban Mode ${antiBanEnabled ? 'ENABLED' :
'DISABLED'}`);
});

[Link]('hack-inv-cleaner')?.addEventListener('change', e
=> {
if (!preCheck("Inventory Cleaner", [Link])) return;
inventoryCleanerEnabled = [Link];
if (inventoryCleanerEnabled) {
inventoryCleanerInterval = setInterval(cleanInventory, 2000); //
Run every 2 seconds
showTemporaryNotification("Inventory Cleaner ENABLED");
} else {
if (inventoryCleanerInterval)
clearInterval(inventoryCleanerInterval);
inventoryCleanerInterval = null;
showTemporaryNotification("Inventory Cleaner DISABLED");
}
});

[Link]('hack-health-color')?.addEventListener('click', ()
=> {
const healthBar =
[Link]("BottomScreenStatBar")[0];
if (healthBar) {
[Link] = defaultAccent;
showTemporaryNotification("Health bar color set");
}
 });

[Link]('hack-ranks')?.addEventListener('click', () => {
if (!preCheck("Ranks")) return;
[Link][1][1].ranks[0] = "developer";
[Link][1][1].ranks[1] = "youtuber";
[Link][1][1].ranks[2] = "super";
showTemporaryNotification("Ranks spoofed");
});

[Link]('hack-player-coords')?.addEventListener('click', ()
=> {
if (!preCheck("Player Coords")) return;
for (const key in [Link]) {
if (key === "1") continue;
const nameObj = [Link][key];
const state = [Link](key, 'position');
if (!state || ![Link]) continue;
const pos = [Link];
const x = [Link](pos[0]); const y = [Link](pos[1]); const z
= [Link](pos[2]);
const baseName = [Link](/\s*\(\-?\d+,\s*\-?\
d+,\s*\-?\d+\)$/, "");
[Link] = `${baseName} (${x}, ${y}, ${z})`;
}
showTemporaryNotification("Player coords updated in leaderboard");
});

[Link]('hack-purge-cookies')?.addEventListener('click', ()
=> {
[Link] = null;
const deleteCookie = (name, path = "/", domain = "") => {
let cookieStr = `${name}=;expires=Thu, 01 Jan 1970 00:00:00
GMT;path=${path};`;
if (domain) cookieStr += `domain=${domain};`;
[Link] = cookieStr;
};
const cookies = [Link](";");
[Link](cookie => {
const eqPos = [Link]("=");
const name = eqPos > -1 ? [Link](0, eqPos).trim() :
[Link]();
deleteCookie(name, "/");
const hostname = [Link];
const domainParts = [Link](".");
if ([Link] > 2) {
const baseDomain = [Link](-2).join(".");
deleteCookie(name, "/", baseDomain);
}
});
showTemporaryNotification("Cookies purged. Reloading...");
setTimeout(() => [Link](), 150);
});

[Link]('hack-discord')?.addEventListener('click', () => {
[Link]("[Link] "_blank");
});

[Link]('hack-manual-inject')?.addEventListener('click', ()
=> {
showTemporaryNotification("Attempting manual injection...");
performInjection();
});
}

setupHackEventListeners();

const modulesToRender = [];

function renderLoop() {
for (const module of modulesToRender) {
[Link]();
}
requestAnimationFrame(renderLoop);
}

loadTheme();
renderLoop();
})();