diff --git a/src/js/jagex2/config/ComType.ts b/src/js/jagex2/config/ComType.ts
index 7b599c4b..93d298c0 100644
--- a/src/js/jagex2/config/ComType.ts
+++ b/src/js/jagex2/config/ComType.ts
@@ -494,7 +494,7 @@ export default class ComType {
     seqFrame: number = 0;
     seqCycle: number = 0;
 
-    getModel = (primaryFrame: number, secondaryFrame: number, active: boolean): Model | null => {
+    getModel(primaryFrame: number, secondaryFrame: number, active: boolean): Model | null {
         let model: Model | null = this.model;
         if (active) {
             model = this.activeModel;
@@ -523,7 +523,7 @@ export default class ComType {
 
         tmp.calculateNormals(64, 768, -50, -10, -50, true);
         return tmp;
-    };
+    }
 
     getAbsoluteX(): number {
         if (this.layer === this.id) {
diff --git a/src/js/jagex2/config/ConfigType.ts b/src/js/jagex2/config/ConfigType.ts
index 72ce309c..869e3be5 100644
--- a/src/js/jagex2/config/ConfigType.ts
+++ b/src/js/jagex2/config/ConfigType.ts
@@ -10,7 +10,7 @@ export abstract class ConfigType {
 
     abstract decode(code: number, dat: Packet): void;
 
-    decodeType = (dat: Packet): this => {
+    decodeType(dat: Packet): this {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const opcode: number = dat.g1;
@@ -20,5 +20,5 @@ export abstract class ConfigType {
             this.decode(opcode, dat);
         }
         return this;
-    };
+    }
 }
diff --git a/src/js/jagex2/config/FloType.ts b/src/js/jagex2/config/FloType.ts
index 1c0e9b6c..70199b67 100644
--- a/src/js/jagex2/config/FloType.ts
+++ b/src/js/jagex2/config/FloType.ts
@@ -81,7 +81,7 @@ export default class FloType extends ConfigType {
     chroma: number = 0;
     hsl: number = 0;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             this.rgb = dat.g3;
             this.setColor(this.rgb);
@@ -96,9 +96,9 @@ export default class FloType extends ConfigType {
         } else {
             console.log('Error unrecognised config code: ', code);
         }
-    };
+    }
 
-    private setColor = (rgb: number): void => {
+    private setColor(rgb: number): void {
         const red: number = ((rgb >> 16) & 0xff) / 256.0;
         const green: number = ((rgb >> 8) & 0xff) / 256.0;
         const blue: number = (rgb & 0xff) / 256.0;
@@ -192,5 +192,5 @@ export default class FloType extends ConfigType {
         }
 
         this.hsl = FloType.hsl24to16(hue, saturation, lightness);
-    };
+    }
 }
diff --git a/src/js/jagex2/config/IdkType.ts b/src/js/jagex2/config/IdkType.ts
index ec26e693..2c3e230d 100644
--- a/src/js/jagex2/config/IdkType.ts
+++ b/src/js/jagex2/config/IdkType.ts
@@ -25,7 +25,7 @@ export default class IdkType extends ConfigType {
     recol_d: Int32Array = new Int32Array(6);
     disable: boolean = false;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             this.type = dat.g1;
         } else if (code === 2) {
@@ -46,9 +46,9 @@ export default class IdkType extends ConfigType {
         } else {
             throw new Error(`Unrecognized idk config code: ${code}`);
         }
-    };
+    }
 
-    getModel = (): Model | null => {
+    getModel(): Model | null {
         if (!this.models) {
             return null;
         }
@@ -69,9 +69,9 @@ export default class IdkType extends ConfigType {
             model?.recolor(this.recol_s[i], this.recol_d[i]);
         }
         return model;
-    };
+    }
 
-    getHeadModel = (): Model => {
+    getHeadModel(): Model {
         let count: number = 0;
 
         const models: (Model | null)[] = new TypedArray1d(5, null);
@@ -87,5 +87,5 @@ export default class IdkType extends ConfigType {
         }
 
         return model;
-    };
+    }
 }
diff --git a/src/js/jagex2/config/LocType.ts b/src/js/jagex2/config/LocType.ts
index 3ae5bc46..4f2318f6 100644
--- a/src/js/jagex2/config/LocType.ts
+++ b/src/js/jagex2/config/LocType.ts
@@ -115,7 +115,7 @@ export default class LocType extends ConfigType {
     zoff: number = 0;
     forcedecor: boolean = false;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             const count: number = dat.g1;
             this.models = new Int32Array(count);
@@ -205,9 +205,9 @@ export default class LocType extends ConfigType {
         } else if (code === 73) {
             this.forcedecor = true;
         }
-    };
+    }
 
-    getModel = (shape: number, angle: number, heightmapSW: number, heightmapSE: number, heightmapNE: number, heightmapNW: number, transformId: number): Model | null => {
+    getModel(shape: number, angle: number, heightmapSW: number, heightmapSE: number, heightmapNE: number, heightmapNW: number, transformId: number): Model | null {
         if (!this.shapes) {
             return null;
         }
@@ -345,9 +345,9 @@ export default class LocType extends ConfigType {
         }
 
         return modified;
-    };
+    }
 
-    private reset = (): void => {
+    private reset(): void {
         this.models = null;
         this.shapes = null;
         this.name = null;
@@ -381,5 +381,5 @@ export default class LocType extends ConfigType {
         this.yoff = 0;
         this.zoff = 0;
         this.forcedecor = false;
-    };
+    }
 }
diff --git a/src/js/jagex2/config/MesAnimType.ts b/src/js/jagex2/config/MesAnimType.ts
index 78c71466..d804eb5b 100644
--- a/src/js/jagex2/config/MesAnimType.ts
+++ b/src/js/jagex2/config/MesAnimType.ts
@@ -18,7 +18,7 @@ export default class MesAnimType extends ConfigType {
 
     len: Int32Array = new Int32Array(4).fill(-1);
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code >= 1 && code < 5) {
             this.len[code - 1] = dat.g2;
         } else if (code === 250) {
@@ -26,5 +26,5 @@ export default class MesAnimType extends ConfigType {
         } else {
             throw new Error(`Unrecognized mesanim config code: ${code}`);
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/config/NpcType.ts b/src/js/jagex2/config/NpcType.ts
index ae831529..09d6391d 100644
--- a/src/js/jagex2/config/NpcType.ts
+++ b/src/js/jagex2/config/NpcType.ts
@@ -85,7 +85,7 @@ export default class NpcType extends ConfigType {
     resizeh: number = 128;
     resizev: number = 128;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             const count: number = dat.g1;
             this.models = new Uint16Array(count);
@@ -150,9 +150,9 @@ export default class NpcType extends ConfigType {
         } else if (code === 98) {
             this.resizev = dat.g2;
         }
-    };
+    }
 
-    getSequencedModel = (primaryTransformId: number, secondaryTransformId: number, seqMask: Int32Array | null): Model | null => {
+    getSequencedModel(primaryTransformId: number, secondaryTransformId: number, seqMask: Int32Array | null): Model | null {
         let tmp: Model | null = null;
         let model: Model | null = null;
         if (NpcType.modelCache) {
@@ -207,9 +207,9 @@ export default class NpcType extends ConfigType {
         }
 
         return null;
-    };
+    }
 
-    getHeadModel = (): Model | null => {
+    getHeadModel(): Model | null {
         if (!this.heads) {
             return null;
         }
@@ -233,5 +233,5 @@ export default class NpcType extends ConfigType {
         }
 
         return model;
-    };
+    }
 }
diff --git a/src/js/jagex2/config/ObjType.ts b/src/js/jagex2/config/ObjType.ts
index ad4e0c8b..d082d9f4 100644
--- a/src/js/jagex2/config/ObjType.ts
+++ b/src/js/jagex2/config/ObjType.ts
@@ -229,7 +229,7 @@ export default class ObjType extends ConfigType {
     certlink: number = -1;
     certtemplate: number = -1;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             this.model = dat.g2;
         } else if (code === 2) {
@@ -322,9 +322,9 @@ export default class ObjType extends ConfigType {
             this.countobj[code - 100] = dat.g2;
             this.countco[code - 100] = dat.g2;
         }
-    };
+    }
 
-    getWornModel = (gender: number): Model | null => {
+    getWornModel(gender: number): Model | null {
         let id1: number = this.manwear;
         if (gender === 1) {
             id1 = this.womanwear;
@@ -369,9 +369,9 @@ export default class ObjType extends ConfigType {
             }
         }
         return model;
-    };
+    }
 
-    getHeadModel = (gender: number): Model | null => {
+    getHeadModel(gender: number): Model | null {
         let head1: number = this.manhead;
         if (gender === 1) {
             head1 = this.womanhead;
@@ -399,9 +399,9 @@ export default class ObjType extends ConfigType {
             }
         }
         return model;
-    };
+    }
 
-    getInterfaceModel = (count: number): Model => {
+    getInterfaceModel(count: number): Model {
         if (this.countobj && this.countco && count > 1) {
             let id: number = -1;
             for (let i: number = 0; i < 10; i++) {
@@ -433,9 +433,9 @@ export default class ObjType extends ConfigType {
         model.pickable = true;
         ObjType.modelCache?.put(BigInt(this.id), model);
         return model;
-    };
+    }
 
-    private toCertificate = (): void => {
+    private toCertificate(): void {
         const template: ObjType = ObjType.get(this.certtemplate);
         this.model = template.model;
         this.zoom2d = template.zoom2d;
@@ -460,9 +460,9 @@ export default class ObjType extends ConfigType {
         this.desc = `Swap this note at any bank for ${article} ${link.name}.`;
 
         this.stackable = true;
-    };
+    }
 
-    private reset = (): void => {
+    private reset(): void {
         this.model = 0;
         this.name = null;
         this.desc = null;
@@ -497,5 +497,5 @@ export default class ObjType extends ConfigType {
         this.countco = null;
         this.certlink = -1;
         this.certtemplate = -1;
-    };
+    }
 }
diff --git a/src/js/jagex2/config/SeqType.ts b/src/js/jagex2/config/SeqType.ts
index 9f39930d..9f2195cf 100644
--- a/src/js/jagex2/config/SeqType.ts
+++ b/src/js/jagex2/config/SeqType.ts
@@ -43,7 +43,7 @@ export default class SeqType extends ConfigType {
     replaycount: number = 99;
     duration: number = 0;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             this.frameCount = dat.g1;
             this.frames = new Int16Array(this.frameCount);
@@ -93,5 +93,5 @@ export default class SeqType extends ConfigType {
         } else {
             throw new Error(`Unrecognized seq config code: ${code}`);
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/config/SpotAnimType.ts b/src/js/jagex2/config/SpotAnimType.ts
index dde5f4a2..3e38055f 100644
--- a/src/js/jagex2/config/SpotAnimType.ts
+++ b/src/js/jagex2/config/SpotAnimType.ts
@@ -32,7 +32,7 @@ export default class SpotAnimType extends ConfigType {
     ambient: number = 0;
     contrast: number = 0;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             this.model = dat.g2;
         } else if (code === 2) {
@@ -60,9 +60,9 @@ export default class SpotAnimType extends ConfigType {
         } else {
             throw new Error(`Unrecognized spotanim config code: ${code}`);
         }
-    };
+    }
 
-    getModel = (): Model => {
+    getModel(): Model {
         let model: Model | null = SpotAnimType.modelCache?.get(BigInt(this.id)) as Model | null;
         if (model) {
             return model;
@@ -75,5 +75,5 @@ export default class SpotAnimType extends ConfigType {
         }
         SpotAnimType.modelCache?.put(BigInt(this.id), model);
         return model;
-    };
+    }
 }
diff --git a/src/js/jagex2/config/VarpType.ts b/src/js/jagex2/config/VarpType.ts
index 74ceca4a..34f672b1 100644
--- a/src/js/jagex2/config/VarpType.ts
+++ b/src/js/jagex2/config/VarpType.ts
@@ -27,7 +27,7 @@ export default class VarpType extends ConfigType {
     transmit: boolean = false;
     code8: boolean = false;
 
-    decode = (code: number, dat: Packet): void => {
+    decode(code: number, dat: Packet): void {
         if (code === 1) {
             this.scope = dat.g1;
         } else if (code === 2) {
@@ -50,5 +50,5 @@ export default class VarpType extends ConfigType {
         } else {
             throw new Error(`Error unrecognised config code: ${code}`);
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/dash3d/entity/NpcEntity.ts b/src/js/jagex2/dash3d/entity/NpcEntity.ts
index 79446784..b5a8c638 100644
--- a/src/js/jagex2/dash3d/entity/NpcEntity.ts
+++ b/src/js/jagex2/dash3d/entity/NpcEntity.ts
@@ -7,7 +7,7 @@ import SeqType from '../../config/SeqType';
 export default class NpcEntity extends PathingEntity {
     type: NpcType | null = null;
 
-    draw = (_loopCycle: number): Model | null => {
+    draw(_loopCycle: number): Model | null {
         if (!this.type) {
             return null;
         }
@@ -44,11 +44,13 @@ export default class NpcEntity extends PathingEntity {
         }
 
         return tmp;
-    };
+    }
 
-    isVisible = (): boolean => this.type !== null;
+    isVisible(): boolean {
+        return this.type !== null;
+    }
 
-    private getSequencedModel = (): Model | null => {
+    private getSequencedModel(): Model | null {
         if (!this.type) {
             return null;
         }
@@ -81,5 +83,5 @@ export default class NpcEntity extends PathingEntity {
         }
         this.height = model.maxY;
         return model;
-    };
+    }
 }
diff --git a/src/js/jagex2/dash3d/entity/PathingEntity.ts b/src/js/jagex2/dash3d/entity/PathingEntity.ts
index c2a101a1..79e434f7 100644
--- a/src/js/jagex2/dash3d/entity/PathingEntity.ts
+++ b/src/js/jagex2/dash3d/entity/PathingEntity.ts
@@ -63,7 +63,7 @@ export default abstract class PathingEntity extends Entity {
 
     abstract isVisible(): boolean;
 
-    move = (teleport: boolean, x: number, z: number): void => {
+    move(teleport: boolean, x: number, z: number): void {
         if (this.primarySeqId !== -1 && SeqType.instances[this.primarySeqId].priority <= 1) {
             this.primarySeqId = -1;
         }
@@ -96,9 +96,9 @@ export default abstract class PathingEntity extends Entity {
         this.pathTileZ[0] = z;
         this.x = this.pathTileX[0] * 128 + this.size * 64;
         this.z = this.pathTileZ[0] * 128 + this.size * 64;
-    };
+    }
 
-    step = (running: boolean, direction: number): void => {
+    step(running: boolean, direction: number): void {
         let nextX: number = this.pathTileX[0];
         let nextZ: number = this.pathTileZ[0];
 
@@ -141,5 +141,5 @@ export default abstract class PathingEntity extends Entity {
         this.pathTileX[0] = nextX;
         this.pathTileZ[0] = nextZ;
         this.pathRunning[0] = running;
-    };
+    }
 }
diff --git a/src/js/jagex2/dash3d/entity/PlayerEntity.ts b/src/js/jagex2/dash3d/entity/PlayerEntity.ts
index c3eb79d6..be048ce1 100644
--- a/src/js/jagex2/dash3d/entity/PlayerEntity.ts
+++ b/src/js/jagex2/dash3d/entity/PlayerEntity.ts
@@ -126,7 +126,7 @@ export default class PlayerEntity extends PathingEntity {
     maxTileZ: number = 0;
     lowMemory: boolean = false;
 
-    draw = (loopCycle: number): Model | null => {
+    draw(loopCycle: number): Model | null {
         if (!this.visible) {
             return null;
         }
@@ -198,11 +198,13 @@ export default class PlayerEntity extends PathingEntity {
 
         model.pickable = true;
         return model;
-    };
+    }
 
-    isVisible = (): boolean => this.visible;
+    isVisible(): boolean {
+        return this.visible;
+    }
 
-    read = (buf: Packet): void => {
+    read(buf: Packet): void {
         buf.pos = 0;
 
         this.gender = buf.g1;
@@ -283,9 +285,9 @@ export default class PlayerEntity extends PathingEntity {
         }
         this.appearanceHashcode <<= 0x1n;
         this.appearanceHashcode += BigInt(this.gender);
-    };
+    }
 
-    getHeadModel = (): Model | null => {
+    getHeadModel(): Model | null {
         if (!this.visible) {
             return null;
         }
@@ -319,9 +321,9 @@ export default class PlayerEntity extends PathingEntity {
         }
 
         return tmp;
-    };
+    }
 
-    private getSequencedModel = (): Model => {
+    private getSequencedModel(): Model {
         let hashCode: bigint = this.appearanceHashcode;
         let primaryTransformId: number = -1;
         let secondaryTransformId: number = -1;
@@ -420,5 +422,5 @@ export default class PlayerEntity extends PathingEntity {
         tmp.labelFaces = null;
         tmp.labelVertices = null;
         return tmp;
-    };
+    }
 }
diff --git a/src/js/jagex2/dash3d/entity/ProjectileEntity.ts b/src/js/jagex2/dash3d/entity/ProjectileEntity.ts
index a28a0dfb..f5c4d9e5 100644
--- a/src/js/jagex2/dash3d/entity/ProjectileEntity.ts
+++ b/src/js/jagex2/dash3d/entity/ProjectileEntity.ts
@@ -46,7 +46,7 @@ export default class ProjectileEntity extends Entity {
         this.offsetY = offsetY;
     }
 
-    updateVelocity = (dstX: number, dstY: number, dstZ: number, cycle: number): void => {
+    updateVelocity(dstX: number, dstY: number, dstZ: number, cycle: number): void {
         if (!this.mobile) {
             const dx: number = dstX - this.srcX;
             const dz: number = dstZ - this.srcZ;
@@ -65,9 +65,9 @@ export default class ProjectileEntity extends Entity {
             this.velocityY = -this.velocity * Math.tan(this.peakPitch * 0.02454369);
         }
         this.accelerationY = ((dstY - this.y - this.velocityY * dt) * 2.0) / (dt * dt);
-    };
+    }
 
-    update = (delta: number): void => {
+    update(delta: number): void {
         this.mobile = true;
         this.x += this.velocityX * delta;
         this.z += this.velocityZ * delta;
@@ -87,9 +87,9 @@ export default class ProjectileEntity extends Entity {
                 this.seqFrame = 0;
             }
         }
-    };
+    }
 
-    draw = (): Model | null => {
+    draw(): Model | null {
         const tmp: Model = this.spotanim.getModel();
         const model: Model = Model.modelShareColored(tmp, true, !this.spotanim.disposeAlpha, false);
 
@@ -107,5 +107,5 @@ export default class ProjectileEntity extends Entity {
         model.rotateX(this.pitch);
         model.calculateNormals(64 + this.spotanim.ambient, 850 + this.spotanim.contrast, -30, -50, -30, true);
         return model;
-    };
+    }
 }
diff --git a/src/js/jagex2/dash3d/entity/SpotAnimEntity.ts b/src/js/jagex2/dash3d/entity/SpotAnimEntity.ts
index 2bf17941..b08c54d3 100644
--- a/src/js/jagex2/dash3d/entity/SpotAnimEntity.ts
+++ b/src/js/jagex2/dash3d/entity/SpotAnimEntity.ts
@@ -26,7 +26,7 @@ export default class SpotAnimEntity extends Entity {
         this.startCycle = cycle + delay;
     }
 
-    update = (delta: number): void => {
+    update(delta: number): void {
         if (!this.type.seq || !this.type.seq.delay) {
             return;
         }
@@ -39,9 +39,9 @@ export default class SpotAnimEntity extends Entity {
                 this.seqComplete = true;
             }
         }
-    };
+    }
 
-    draw = (): Model => {
+    draw(): Model {
         const tmp: Model = this.type.getModel();
         const model: Model = Model.modelShareColored(tmp, true, !this.type.disposeAlpha, false);
         if (!this.seqComplete && this.type.seq && this.type.seq.frames) {
@@ -70,5 +70,5 @@ export default class SpotAnimEntity extends Entity {
 
         model.calculateNormals(64 + this.type.ambient, 850 + this.type.contrast, -30, -50, -30, true);
         return model;
-    };
+    }
 }
diff --git a/src/js/jagex2/datastruct/HashTable.ts b/src/js/jagex2/datastruct/HashTable.ts
index 26dec58f..86db0d84 100644
--- a/src/js/jagex2/datastruct/HashTable.ts
+++ b/src/js/jagex2/datastruct/HashTable.ts
@@ -13,7 +13,7 @@ export default class HashTable {
         }
     }
 
-    get = (key: bigint): Linkable | null => {
+    get(key: bigint): Linkable | null {
         const start: Linkable = this.buckets[Number(key & BigInt(this.bucketCount - 1))];
         const next: Linkable | null = start.next;
         if (!next) {
@@ -30,9 +30,9 @@ export default class HashTable {
         }
 
         return null;
-    };
+    }
 
-    put = (key: bigint, value: Linkable): void => {
+    put(key: bigint, value: Linkable): void {
         if (value.prev) {
             value.unlink();
         }
@@ -45,5 +45,5 @@ export default class HashTable {
         }
         value.next.prev = value;
         value.key = key;
-    };
+    }
 }
diff --git a/src/js/jagex2/datastruct/Hashable.ts b/src/js/jagex2/datastruct/Hashable.ts
index c3fcab46..0e9f1645 100644
--- a/src/js/jagex2/datastruct/Hashable.ts
+++ b/src/js/jagex2/datastruct/Hashable.ts
@@ -11,7 +11,7 @@ export default class Hashable extends Linkable {
         this.prevHashable = this;
     }
 
-    uncache = (): void => {
+    uncache(): void {
         if (!this.prevHashable || !this.nextHashable) {
             return;
         }
@@ -19,5 +19,5 @@ export default class Hashable extends Linkable {
         this.nextHashable.prevHashable = this.prevHashable;
         this.nextHashable = null;
         this.prevHashable = null;
-    };
+    }
 }
diff --git a/src/js/jagex2/datastruct/LinkList.ts b/src/js/jagex2/datastruct/LinkList.ts
index 1184565d..056b09df 100644
--- a/src/js/jagex2/datastruct/LinkList.ts
+++ b/src/js/jagex2/datastruct/LinkList.ts
@@ -14,7 +14,7 @@ export default class LinkList {
         this.sentinel = head;
     }
 
-    addTail = (node: Linkable): void => {
+    addTail(node: Linkable): void {
         if (node.prev) {
             node.unlink();
         }
@@ -24,9 +24,9 @@ export default class LinkList {
             node.prev.next = node;
         }
         node.next.prev = node;
-    };
+    }
 
-    addHead = (node: Linkable): void => {
+    addHead(node: Linkable): void {
         if (node.prev) {
             node.unlink();
         }
@@ -36,18 +36,18 @@ export default class LinkList {
         if (node.next) {
             node.next.prev = node;
         }
-    };
+    }
 
-    removeHead = (): Linkable | null => {
+    removeHead(): Linkable | null {
         const node: Linkable | null = this.sentinel.next;
         if (node === this.sentinel) {
             return null;
         }
         node?.unlink();
         return node;
-    };
+    }
 
-    head = (): Linkable | null => {
+    head(): Linkable | null {
         const node: Linkable | null = this.sentinel.next;
         if (node === this.sentinel) {
             this.cursor = null;
@@ -55,9 +55,9 @@ export default class LinkList {
         }
         this.cursor = node?.next || null;
         return node;
-    };
+    }
 
-    tail = (): Linkable | null => {
+    tail(): Linkable | null {
         const node: Linkable | null = this.sentinel.prev;
         if (node === this.sentinel) {
             this.cursor = null;
@@ -65,9 +65,9 @@ export default class LinkList {
         }
         this.cursor = node?.prev || null;
         return node;
-    };
+    }
 
-    next = (): Linkable | null => {
+    next(): Linkable | null {
         const node: Linkable | null = this.cursor;
         if (node === this.sentinel) {
             this.cursor = null;
@@ -75,9 +75,9 @@ export default class LinkList {
         }
         this.cursor = node?.next || null;
         return node;
-    };
+    }
 
-    prev = (): Linkable | null => {
+    prev(): Linkable | null {
         const node: Linkable | null = this.cursor;
         if (node === this.sentinel) {
             this.cursor = null;
@@ -85,9 +85,9 @@ export default class LinkList {
         }
         this.cursor = node?.prev || null;
         return node;
-    };
+    }
 
-    clear = (): void => {
+    clear(): void {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const node: Linkable | null = this.sentinel.next;
@@ -96,5 +96,5 @@ export default class LinkList {
             }
             node?.unlink();
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/datastruct/Linkable.ts b/src/js/jagex2/datastruct/Linkable.ts
index 7991c0f8..13d38c0b 100644
--- a/src/js/jagex2/datastruct/Linkable.ts
+++ b/src/js/jagex2/datastruct/Linkable.ts
@@ -9,7 +9,7 @@ export default class Linkable {
         this.prev = this;
     }
 
-    unlink = (): void => {
+    unlink(): void {
         if (!this.prev || !this.next) {
             return;
         }
@@ -17,5 +17,5 @@ export default class Linkable {
         this.next.prev = this.prev;
         this.next = null;
         this.prev = null;
-    };
+    }
 }
diff --git a/src/js/jagex2/datastruct/LruCache.ts b/src/js/jagex2/datastruct/LruCache.ts
index 37e2a8f1..35b5d72a 100644
--- a/src/js/jagex2/datastruct/LruCache.ts
+++ b/src/js/jagex2/datastruct/LruCache.ts
@@ -16,15 +16,15 @@ export default class LruCache {
         this.history = new Stack();
     }
 
-    get = (key: bigint): Hashable | null => {
+    get(key: bigint): Hashable | null {
         const node: Hashable | null = this.hashtable.get(key) as Hashable | null;
         if (node) {
             this.history.push(node);
         }
         return node;
-    };
+    }
 
-    put = (key: bigint, value: Hashable): void => {
+    put(key: bigint, value: Hashable): void {
         if (this.available === 0) {
             const node: Hashable | null = this.history.pop();
             node?.unlink();
@@ -34,9 +34,9 @@ export default class LruCache {
         }
         this.hashtable.put(key, value);
         this.history.push(value);
-    };
+    }
 
-    clear = (): void => {
+    clear(): void {
         const node: Hashable | null = this.history.pop();
         if (!node) {
             this.available = this.capacity;
@@ -44,5 +44,5 @@ export default class LruCache {
         }
         node.unlink();
         node.uncache();
-    };
+    }
 }
diff --git a/src/js/jagex2/datastruct/Stack.ts b/src/js/jagex2/datastruct/Stack.ts
index 48999442..4163c569 100644
--- a/src/js/jagex2/datastruct/Stack.ts
+++ b/src/js/jagex2/datastruct/Stack.ts
@@ -7,7 +7,7 @@ export default class Stack {
         this.head = new Hashable();
     }
 
-    push = (node: Hashable): void => {
+    push(node: Hashable): void {
         if (node.prevHashable) {
             node.uncache();
         }
@@ -17,9 +17,9 @@ export default class Stack {
             node.prevHashable.nextHashable = node;
         }
         node.nextHashable.prevHashable = node;
-    };
+    }
 
-    pop = (): Hashable | null => {
+    pop(): Hashable | null {
         const node: Hashable | null = this.head.nextHashable;
         if (node === this.head) {
             return null;
@@ -27,5 +27,5 @@ export default class Stack {
             node?.uncache();
             return node;
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/graphics/Model.ts b/src/js/jagex2/graphics/Model.ts
index 801f592f..45e516a1 100644
--- a/src/js/jagex2/graphics/Model.ts
+++ b/src/js/jagex2/graphics/Model.ts
@@ -1554,7 +1554,7 @@ export default class Model extends Hashable {
         this.vertexNormalOriginal = type.vertexNormalOriginal ?? null;
     }
 
-    calculateBoundsCylinder = (): void => {
+    calculateBoundsCylinder(): void {
         this.maxY = 0;
         this.radius = 0;
         this.minY = 0;
@@ -1581,9 +1581,9 @@ export default class Model extends Hashable {
         this.radius = (Math.sqrt(this.radius) + 0.99) | 0;
         this.minDepth = (Math.sqrt(this.radius * this.radius + this.maxY * this.maxY) + 0.99) | 0;
         this.maxDepth = this.minDepth + ((Math.sqrt(this.radius * this.radius + this.minY * this.minY) + 0.99) | 0);
-    };
+    }
 
-    calculateBoundsY = (): void => {
+    calculateBoundsY(): void {
         this.maxY = 0;
         this.minY = 0;
 
@@ -1601,9 +1601,9 @@ export default class Model extends Hashable {
 
         this.minDepth = (Math.sqrt(this.radius * this.radius + this.maxY * this.maxY) + 0.99) | 0;
         this.maxDepth = this.minDepth + ((Math.sqrt(this.radius * this.radius + this.minY * this.minY) + 0.99) | 0);
-    };
+    }
 
-    createLabelReferences = (): void => {
+    createLabelReferences(): void {
         if (this.vertexLabel) {
             const labelVertexCount: Int32Array = new Int32Array(256);
             let count: number = 0;
@@ -1659,9 +1659,9 @@ export default class Model extends Hashable {
             }
             this.faceLabel = null;
         }
-    };
+    }
 
-    applyTransforms = (primaryId: number, secondaryId: number, mask: Int32Array | null): void => {
+    applyTransforms(primaryId: number, secondaryId: number, mask: Int32Array | null): void {
         if (primaryId === -1) {
             return;
         }
@@ -1715,9 +1715,9 @@ export default class Model extends Hashable {
                 }
             }
         }
-    };
+    }
 
-    applyTransform = (id: number): void => {
+    applyTransform(id: number): void {
         if (!this.labelVertices || id === -1 || !SeqFrame.instances[id]) {
             return;
         }
@@ -1737,17 +1737,17 @@ export default class Model extends Hashable {
             const base: number = transform.bases[i];
             this.applyTransform2(transform.x[i], transform.y[i], transform.z[i], skeleton.labels[base], skeleton.types[base]);
         }
-    };
+    }
 
-    rotateY90 = (): void => {
+    rotateY90(): void {
         for (let v: number = 0; v < this.vertexCount; v++) {
             const tmp: number = this.vertexX[v];
             this.vertexX[v] = this.vertexZ[v];
             this.vertexZ[v] = -tmp;
         }
-    };
+    }
 
-    rotateX = (angle: number): void => {
+    rotateX(angle: number): void {
         const sin: number = Draw3D.sin[angle];
         const cos: number = Draw3D.cos[angle];
 
@@ -1756,17 +1756,17 @@ export default class Model extends Hashable {
             this.vertexZ[v] = (this.vertexY[v] * sin + this.vertexZ[v] * cos) >> 16;
             this.vertexY[v] = tmp;
         }
-    };
+    }
 
-    translate = (y: number, x: number, z: number): void => {
+    translate(y: number, x: number, z: number): void {
         for (let v: number = 0; v < this.vertexCount; v++) {
             this.vertexX[v] += x;
             this.vertexY[v] += y;
             this.vertexZ[v] += z;
         }
-    };
+    }
 
-    recolor = (src: number, dst: number): void => {
+    recolor(src: number, dst: number): void {
         if (!this.faceColor) {
             return;
         }
@@ -1776,9 +1776,9 @@ export default class Model extends Hashable {
                 this.faceColor[f] = dst;
             }
         }
-    };
+    }
 
-    rotateY180 = (): void => {
+    rotateY180(): void {
         for (let v: number = 0; v < this.vertexCount; v++) {
             this.vertexZ[v] = -this.vertexZ[v];
         }
@@ -1788,17 +1788,17 @@ export default class Model extends Hashable {
             this.faceVertexA[f] = this.faceVertexC[f];
             this.faceVertexC[f] = temp;
         }
-    };
+    }
 
-    scale = (x: number, y: number, z: number): void => {
+    scale(x: number, y: number, z: number): void {
         for (let v: number = 0; v < this.vertexCount; v++) {
             this.vertexX[v] = ((this.vertexX[v] * x) / 128) | 0;
             this.vertexY[v] = ((this.vertexY[v] * y) / 128) | 0;
             this.vertexZ[v] = ((this.vertexZ[v] * z) / 128) | 0;
         }
-    };
+    }
 
-    calculateNormals = (lightAmbient: number, lightAttenuation: number, lightSrcX: number, lightSrcY: number, lightSrcZ: number, applyLighting: boolean): void => {
+    calculateNormals(lightAmbient: number, lightAttenuation: number, lightSrcX: number, lightSrcY: number, lightSrcZ: number, applyLighting: boolean): void {
         const lightMagnitude: number = Math.sqrt(lightSrcX * lightSrcX + lightSrcY * lightSrcY + lightSrcZ * lightSrcZ) | 0;
         const attenuation: number = (lightAttenuation * lightMagnitude) >> 8;
 
@@ -1905,9 +1905,9 @@ export default class Model extends Hashable {
         } else {
             this.calculateBoundsAABB();
         }
-    };
+    }
 
-    applyLighting = (lightAmbient: number, lightAttenuation: number, lightSrcX: number, lightSrcY: number, lightSrcZ: number): void => {
+    applyLighting(lightAmbient: number, lightAttenuation: number, lightSrcX: number, lightSrcY: number, lightSrcZ: number): void {
         for (let f: number = 0; f < this.faceCount; f++) {
             const a: number = this.faceVertexA[f];
             const b: number = this.faceVertexB[f];
@@ -1965,11 +1965,11 @@ export default class Model extends Hashable {
         }
 
         this.faceColor = null;
-    };
+    }
 
     // todo: better name, Java relies on overloads
     // this function is NOT near-clipped (helps with performance) so be careful how you use it!
-    drawSimple = (pitch: number, yaw: number, roll: number, eyePitch: number, eyeX: number, eyeY: number, eyeZ: number): void => {
+    drawSimple(pitch: number, yaw: number, roll: number, eyePitch: number, eyeX: number, eyeY: number, eyeZ: number): void {
         const sinPitch: number = Draw3D.sin[pitch];
         const cosPitch: number = Draw3D.cos[pitch];
 
@@ -2035,10 +2035,10 @@ export default class Model extends Hashable {
         } catch (err) {
             /* empty */
         }
-    };
+    }
 
     // todo: better name, Java relies on overloads
-    draw = (yaw: number, sinEyePitch: number, cosEyePitch: number, sinEyeYaw: number, cosEyeYaw: number, relativeX: number, relativeY: number, relativeZ: number, bitset: number): void => {
+    draw(yaw: number, sinEyePitch: number, cosEyePitch: number, sinEyeYaw: number, cosEyeYaw: number, relativeX: number, relativeY: number, relativeZ: number, bitset: number): void {
         const zPrime: number = (relativeZ * cosEyeYaw - relativeX * sinEyeYaw) >> 16;
         const midZ: number = (relativeY * sinEyePitch + zPrime * cosEyePitch) >> 16;
         const radiusCosEyePitch: number = (this.radius * cosEyePitch) >> 16;
@@ -2170,10 +2170,10 @@ export default class Model extends Hashable {
         } catch (err) {
             /* empty */
         }
-    };
+    }
 
     // todo: better name, Java relies on overloads
-    private draw2 = (clipped: boolean, picking: boolean, bitset: number, wireframe: boolean = false): void => {
+    private draw2(clipped: boolean, picking: boolean, bitset: number, wireframe: boolean = false): void {
         if (Model.checkHoverFace) {
             this.pickedFace = -1;
             this.pickedFaceDepth = -1;
@@ -2417,9 +2417,9 @@ export default class Model extends Hashable {
                 }
             }
         }
-    };
+    }
 
-    private drawFace = (face: number, wireframe: boolean = false): void => {
+    private drawFace(face: number, wireframe: boolean = false): void {
         if (Model.faceNearClipped && Model.faceNearClipped[face]) {
             this.drawNearClippedFace(face, wireframe);
             return;
@@ -2517,9 +2517,9 @@ export default class Model extends Hashable {
                 this.faceColor[face]
             );
         }
-    };
+    }
 
-    private drawNearClippedFace = (face: number, wireframe: boolean = false): void => {
+    private drawNearClippedFace(face: number, wireframe: boolean = false): void {
         let elements: number = 0;
 
         if (Model.vertexViewSpaceZ) {
@@ -2815,9 +2815,9 @@ export default class Model extends Hashable {
                 );
             }
         }
-    };
+    }
 
-    private applyTransform2 = (x: number, y: number, z: number, labels: Uint8Array | null, type: number): void => {
+    private applyTransform2(x: number, y: number, z: number, labels: Uint8Array | null, type: number): void {
         if (!labels) {
             return;
         }
@@ -2974,9 +2974,9 @@ export default class Model extends Hashable {
                 }
             }
         }
-    };
+    }
 
-    private calculateBoundsAABB = (): void => {
+    private calculateBoundsAABB(): void {
         this.maxY = 0;
         this.radius = 0;
         this.minY = 0;
@@ -3023,9 +3023,9 @@ export default class Model extends Hashable {
         this.radius = Math.sqrt(this.radius) | 0;
         this.minDepth = Math.sqrt(this.radius * this.radius + this.maxY * this.maxY) | 0;
         this.maxDepth = this.minDepth + (Math.sqrt(this.radius * this.radius + this.minY * this.minY) | 0);
-    };
+    }
 
-    private pointWithinTriangle = (x: number, y: number, yA: number, yB: number, yC: number, xA: number, xB: number, xC: number): boolean => {
+    private pointWithinTriangle(x: number, y: number, yA: number, yB: number, yC: number, xA: number, xB: number, xC: number): boolean {
         if (y < yA && y < yB && y < yC) {
             return false;
         } else if (y > yA && y > yB && y > yC) {
@@ -3035,9 +3035,9 @@ export default class Model extends Hashable {
         } else {
             return x <= xA || x <= xB || x <= xC;
         }
-    };
+    }
 
-    drawFaceOutline = (face: number): void => {
+    drawFaceOutline(face: number): void {
         if (!Model.vertexScreenX || !Model.vertexScreenY || !this.faceColorA || !this.faceColorB || !this.faceColorC) {
             return;
         }
@@ -3049,5 +3049,5 @@ export default class Model extends Hashable {
         Draw3D.drawLine(Model.vertexScreenX[a], Model.vertexScreenY[a], Model.vertexScreenX[b], Model.vertexScreenY[b], Draw3D.palette[1000]);
         Draw3D.drawLine(Model.vertexScreenX[b], Model.vertexScreenY[b], Model.vertexScreenX[c], Model.vertexScreenY[c], Draw3D.palette[1000]);
         Draw3D.drawLine(Model.vertexScreenX[c], Model.vertexScreenY[c], Model.vertexScreenX[a], Model.vertexScreenY[a], Draw3D.palette[1000]);
-    };
+    }
 }
diff --git a/src/js/jagex2/graphics/Pix24.ts b/src/js/jagex2/graphics/Pix24.ts
index 0d100d63..19a2b23a 100644
--- a/src/js/jagex2/graphics/Pix24.ts
+++ b/src/js/jagex2/graphics/Pix24.ts
@@ -108,11 +108,11 @@ export default class Pix24 extends Hashable {
         return image;
     };
 
-    bind = (): void => {
+    bind(): void {
         Draw2D.bind(this.pixels, this.width, this.height);
-    };
+    }
 
-    draw = (x: number, y: number): void => {
+    draw(x: number, y: number): void {
         x |= 0;
         y |= 0;
 
@@ -160,9 +160,9 @@ export default class Pix24 extends Hashable {
         if (w > 0 && h > 0) {
             this.copyImageDraw(w, h, this.pixels, srcOff, srcStep, Draw2D.pixels, dstOff, dstStep);
         }
-    };
+    }
 
-    drawAlpha = (alpha: number, x: number, y: number): void => {
+    drawAlpha(alpha: number, x: number, y: number): void {
         x |= 0;
         y |= 0;
 
@@ -208,9 +208,9 @@ export default class Pix24 extends Hashable {
         if (w > 0 && h > 0) {
             this.copyPixelsAlpha(w, h, this.pixels, srcStep, srcOff, Draw2D.pixels, dstStep, dstOff, alpha);
         }
-    };
+    }
 
-    blitOpaque = (x: number, y: number): void => {
+    blitOpaque(x: number, y: number): void {
         x |= 0;
         y |= 0;
 
@@ -258,9 +258,9 @@ export default class Pix24 extends Hashable {
         if (w > 0 && h > 0) {
             this.copyImageBlitOpaque(w, h, this.pixels, srcOff, srcStep, Draw2D.pixels, dstOff, dstStep);
         }
-    };
+    }
 
-    flipHorizontally = (): void => {
+    flipHorizontally(): void {
         const pixels: Int32Array = this.pixels;
         const width: number = this.width;
         const height: number = this.height;
@@ -276,9 +276,9 @@ export default class Pix24 extends Hashable {
                 pixels[off2] = tmp;
             }
         }
-    };
+    }
 
-    flipVertically = (): void => {
+    flipVertically(): void {
         const pixels: Int32Array = this.pixels;
         const width: number = this.width;
         const height: number = this.height;
@@ -293,9 +293,9 @@ export default class Pix24 extends Hashable {
                 pixels[off2] = tmp;
             }
         }
-    };
+    }
 
-    translate = (r: number, g: number, b: number): void => {
+    translate(r: number, g: number, b: number): void {
         for (let i: number = 0; i < this.pixels.length; i++) {
             const rgb: number = this.pixels[i];
 
@@ -327,9 +327,9 @@ export default class Pix24 extends Hashable {
                 this.pixels[i] = (red << 16) + (green << 8) + blue;
             }
         }
-    };
+    }
 
-    crop = (x: number, y: number, w: number, h: number): void => {
+    crop(x: number, y: number, w: number, h: number): void {
         x |= 0;
         y |= 0;
         w |= 0;
@@ -397,9 +397,9 @@ export default class Pix24 extends Hashable {
         } catch (e) {
             console.error('error in sprite clipping routine');
         }
-    };
+    }
 
-    drawRotatedMasked = (x: number, y: number, w: number, h: number, lineStart: Int32Array, lineWidth: Int32Array, anchorX: number, anchorY: number, theta: number, zoom: number): void => {
+    drawRotatedMasked(x: number, y: number, w: number, h: number, lineStart: Int32Array, lineWidth: Int32Array, anchorX: number, anchorY: number, theta: number, zoom: number): void {
         x |= 0;
         y |= 0;
         w |= 0;
@@ -437,9 +437,9 @@ export default class Pix24 extends Hashable {
         } catch (e) {
             /* empty */
         }
-    };
+    }
 
-    drawMasked = (x: number, y: number, mask: Pix8): void => {
+    drawMasked(x: number, y: number, mask: Pix8): void {
         x |= 0;
         y |= 0;
 
@@ -485,9 +485,9 @@ export default class Pix24 extends Hashable {
         if (w > 0 && h > 0) {
             this.copyPixelsMasked(w, h, this.pixels, srcOff, srcStep, Draw2D.pixels, dstStep, dstOff, mask.pixels);
         }
-    };
+    }
 
-    private scale = (w: number, h: number, src: Int32Array, offW: number, offH: number, dst: Int32Array, dstStep: number, dstOff: number, currentW: number, scaleCropWidth: number, scaleCropHeight: number): void => {
+    private scale(w: number, h: number, src: Int32Array, offW: number, offH: number, dst: Int32Array, dstStep: number, dstOff: number, currentW: number, scaleCropWidth: number, scaleCropHeight: number): void {
         try {
             const lastOffW: number = offW;
             for (let y: number = -h; y < 0; y++) {
@@ -508,9 +508,9 @@ export default class Pix24 extends Hashable {
         } catch (e) {
             console.error('error in plot_scale');
         }
-    };
+    }
 
-    private copyImageBlitOpaque = (w: number, h: number, src: Int32Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number): void => {
+    private copyImageBlitOpaque(w: number, h: number, src: Int32Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number): void {
         const qw: number = -(w >> 2);
         w = -(w & 0x3);
 
@@ -529,9 +529,9 @@ export default class Pix24 extends Hashable {
             dstOff += dstStep;
             srcOff += srcStep;
         }
-    };
+    }
 
-    private copyPixelsAlpha = (w: number, h: number, src: Int32Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number, alpha: number): void => {
+    private copyPixelsAlpha(w: number, h: number, src: Int32Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number, alpha: number): void {
         const invAlpha: number = 256 - alpha;
 
         for (let y: number = -h; y < 0; y++) {
@@ -548,9 +548,9 @@ export default class Pix24 extends Hashable {
             dstOff += dstStep;
             srcOff += srcStep;
         }
-    };
+    }
 
-    private copyImageDraw = (w: number, h: number, src: Int32Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number): void => {
+    private copyImageDraw(w: number, h: number, src: Int32Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number): void {
         const qw: number = -(w >> 2);
         w = -(w & 0x3);
 
@@ -597,9 +597,9 @@ export default class Pix24 extends Hashable {
             dstOff += dstStep;
             srcOff += srcStep;
         }
-    };
+    }
 
-    private copyPixelsMasked = (w: number, h: number, src: Int32Array, srcStep: number, srcOff: number, dst: Int32Array, dstOff: number, dstStep: number, mask: Int8Array): void => {
+    private copyPixelsMasked(w: number, h: number, src: Int32Array, srcStep: number, srcOff: number, dst: Int32Array, dstOff: number, dstStep: number, mask: Int8Array): void {
         const qw: number = -(w >> 2);
         w = -(w & 0x3);
 
@@ -646,5 +646,5 @@ export default class Pix24 extends Hashable {
             dstOff += dstStep;
             srcOff += srcStep;
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/graphics/Pix8.ts b/src/js/jagex2/graphics/Pix8.ts
index 1a5164b2..b85b4edb 100644
--- a/src/js/jagex2/graphics/Pix8.ts
+++ b/src/js/jagex2/graphics/Pix8.ts
@@ -89,7 +89,7 @@ export default class Pix8 extends Hashable {
         return image;
     };
 
-    draw = (x: number, y: number): void => {
+    draw(x: number, y: number): void {
         x |= 0;
         y |= 0;
 
@@ -135,9 +135,9 @@ export default class Pix8 extends Hashable {
         if (w > 0 && h > 0) {
             this.copyImage(w, h, this.pixels, srcOff, srcStep, Draw2D.pixels, dstOff, dstStep);
         }
-    };
+    }
 
-    flipHorizontally = (): void => {
+    flipHorizontally(): void {
         const pixels: Int8Array = this.pixels;
         const width: number = this.width;
         const height: number = this.height;
@@ -153,9 +153,9 @@ export default class Pix8 extends Hashable {
                 pixels[off2] = tmp;
             }
         }
-    };
+    }
 
-    flipVertically = (): void => {
+    flipVertically(): void {
         const pixels: Int8Array = this.pixels;
         const width: number = this.width;
         const height: number = this.height;
@@ -170,9 +170,9 @@ export default class Pix8 extends Hashable {
                 pixels[off2] = tmp;
             }
         }
-    };
+    }
 
-    translate = (r: number, g: number, b: number): void => {
+    translate(r: number, g: number, b: number): void {
         for (let i: number = 0; i < this.palette.length; i++) {
             let red: number = (this.palette[i] >> 16) & 0xff;
             red += r;
@@ -200,9 +200,9 @@ export default class Pix8 extends Hashable {
 
             this.palette[i] = (red << 16) + (green << 8) + blue;
         }
-    };
+    }
 
-    shrink = (): void => {
+    shrink(): void {
         this.cropW |= 0;
         this.cropH |= 0;
         this.cropW /= 2;
@@ -222,9 +222,9 @@ export default class Pix8 extends Hashable {
         this.height = this.cropH;
         this.cropX = 0;
         this.cropY = 0;
-    };
+    }
 
-    crop = (): void => {
+    crop(): void {
         if (this.width === this.cropW && this.height === this.cropH) {
             return;
         }
@@ -241,9 +241,9 @@ export default class Pix8 extends Hashable {
         this.height = this.cropH;
         this.cropX = 0;
         this.cropY = 0;
-    };
+    }
 
-    private copyImage = (w: number, h: number, src: Int8Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number): void => {
+    private copyImage(w: number, h: number, src: Int8Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number): void {
         const qw: number = -(w >> 2);
         w = -(w & 0x3);
 
@@ -290,5 +290,5 @@ export default class Pix8 extends Hashable {
             dstOff += dstStep;
             srcOff += srcStep;
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/graphics/PixFont.ts b/src/js/jagex2/graphics/PixFont.ts
index acf43ae7..c8e6293e 100644
--- a/src/js/jagex2/graphics/PixFont.ts
+++ b/src/js/jagex2/graphics/PixFont.ts
@@ -119,7 +119,7 @@ export default class PixFont extends Hashable {
         return font;
     };
 
-    drawString = (x: number, y: number, str: string | null, color: number): void => {
+    drawString(x: number, y: number, str: string | null, color: number): void {
         if (!str) {
             return;
         }
@@ -138,9 +138,9 @@ export default class PixFont extends Hashable {
 
             x += this.charAdvance[c];
         }
-    };
+    }
 
-    drawStringTaggable = (x: number, y: number, str: string, color: number, shadowed: boolean): void => {
+    drawStringTaggable(x: number, y: number, str: string, color: number, shadowed: boolean): void {
         x |= 0;
         y |= 0;
 
@@ -163,9 +163,9 @@ export default class PixFont extends Hashable {
                 x += this.charAdvance[c];
             }
         }
-    };
+    }
 
-    stringWidth = (str: string | null): number => {
+    stringWidth(str: string | null): number {
         if (!str) {
             return 0;
         }
@@ -181,16 +181,16 @@ export default class PixFont extends Hashable {
         }
 
         return w;
-    };
+    }
 
-    drawStringTaggableCenter = (x: number, y: number, str: string, color: number, shadowed: boolean): void => {
+    drawStringTaggableCenter(x: number, y: number, str: string, color: number, shadowed: boolean): void {
         x |= 0;
         y |= 0;
 
         this.drawStringTaggable(x - this.stringWidth(str) / 2, y, str, color, shadowed);
-    };
+    }
 
-    drawStringCenter = (x: number, y: number, str: string | null, color: number): void => {
+    drawStringCenter(x: number, y: number, str: string | null, color: number): void {
         if (!str) {
             return;
         }
@@ -199,9 +199,9 @@ export default class PixFont extends Hashable {
         y |= 0;
 
         this.drawString(x - this.stringWidth(str) / 2, y, str, color);
-    };
+    }
 
-    drawStringTooltip = (x: number, y: number, str: string, color: number, shadowed: boolean, seed: number): void => {
+    drawStringTooltip(x: number, y: number, str: string, color: number, shadowed: boolean, seed: number): void {
         x |= 0;
         y |= 0;
 
@@ -229,9 +229,9 @@ export default class PixFont extends Hashable {
                 }
             }
         }
-    };
+    }
 
-    drawStringRight = (x: number, y: number, str: string, color: number, shadowed: boolean = true): void => {
+    drawStringRight(x: number, y: number, str: string, color: number, shadowed: boolean = true): void {
         x |= 0;
         y |= 0;
 
@@ -239,9 +239,9 @@ export default class PixFont extends Hashable {
             this.drawString(x - this.stringWidth(str) + 1, y + 1, str, Colors.BLACK);
         }
         this.drawString(x - this.stringWidth(str), y, str, color);
-    };
+    }
 
-    drawCenteredWave = (x: number, y: number, str: string | null, color: number, phase: number): void => {
+    drawCenteredWave(x: number, y: number, str: string | null, color: number, phase: number): void {
         if (!str) {
             return;
         }
@@ -261,9 +261,9 @@ export default class PixFont extends Hashable {
 
             x += this.charAdvance[c];
         }
-    };
+    }
 
-    drawChar = (data: Int8Array, x: number, y: number, w: number, h: number, color: number): void => {
+    drawChar(data: Int8Array, x: number, y: number, w: number, h: number, color: number): void {
         x |= 0;
         y |= 0;
         w |= 0;
@@ -307,9 +307,9 @@ export default class PixFont extends Hashable {
         if (w > 0 && h > 0) {
             this.drawMask(w, h, data, srcOff, srcStep, Draw2D.pixels, dstOff, dstStep, color);
         }
-    };
+    }
 
-    drawCharAlpha = (x: number, y: number, w: number, h: number, color: number, alpha: number, mask: Int8Array): void => {
+    drawCharAlpha(x: number, y: number, w: number, h: number, color: number, alpha: number, mask: Int8Array): void {
         x |= 0;
         y |= 0;
         w |= 0;
@@ -353,9 +353,9 @@ export default class PixFont extends Hashable {
         if (w > 0 && h > 0) {
             this.drawMaskAlpha(w, h, Draw2D.pixels, dstOff, dstStep, mask, srcOff, srcStep, color, alpha);
         }
-    };
+    }
 
-    private drawMask = (w: number, h: number, src: Int8Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number, rgb: number): void => {
+    private drawMask(w: number, h: number, src: Int8Array, srcOff: number, srcStep: number, dst: Int32Array, dstOff: number, dstStep: number, rgb: number): void {
         w |= 0;
         h |= 0;
 
@@ -400,9 +400,9 @@ export default class PixFont extends Hashable {
             dstOff += dstStep;
             srcOff += srcStep;
         }
-    };
+    }
 
-    private drawMaskAlpha = (w: number, h: number, dst: Int32Array, dstOff: number, dstStep: number, mask: Int8Array, maskOff: number, maskStep: number, color: number, alpha: number): void => {
+    private drawMaskAlpha(w: number, h: number, dst: Int32Array, dstOff: number, dstStep: number, mask: Int8Array, maskOff: number, maskStep: number, color: number, alpha: number): void {
         w |= 0;
         h |= 0;
 
@@ -422,9 +422,9 @@ export default class PixFont extends Hashable {
             dstOff += dstStep;
             maskOff += maskStep;
         }
-    };
+    }
 
-    evaluateTag = (tag: string): number => {
+    evaluateTag(tag: string): number {
         if (tag === 'red') {
             return Colors.RED;
         } else if (tag === 'gre') {
@@ -462,7 +462,7 @@ export default class PixFont extends Hashable {
         } else {
             return Colors.BLACK;
         }
-    };
+    }
 
     //
 
diff --git a/src/js/jagex2/graphics/PixMap.ts b/src/js/jagex2/graphics/PixMap.ts
index ec1f219d..55a91f1c 100644
--- a/src/js/jagex2/graphics/PixMap.ts
+++ b/src/js/jagex2/graphics/PixMap.ts
@@ -20,20 +20,20 @@ export default class PixMap {
         this.bind();
     }
 
-    clear = (): void => {
+    clear(): void {
         this.pixels.fill(0);
-    };
+    }
 
-    bind = (): void => {
+    bind(): void {
         Draw2D.bind(this.pixels, this.width, this.height);
-    };
+    }
 
-    draw = (width: number, height: number): void => {
+    draw(width: number, height: number): void {
         this.#setPixels();
         this.ctx.putImageData(this.image, width, height);
-    };
+    }
 
-    #setPixels = (): void => {
+    #setPixels(): void {
         const length: number = this.pixels.length;
         const pixels: Int32Array = this.pixels;
         const paint: Uint32Array = this.paint;
@@ -41,5 +41,5 @@ export default class PixMap {
             const pixel: number = pixels[i];
             paint[i] = ((pixel >> 16) & 0xff) | (((pixel >> 8) & 0xff) << 8) | ((pixel & 0xff) << 16) | 0xff000000;
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/io/ClientStream.ts b/src/js/jagex2/io/ClientStream.ts
index 65fd1f44..e76d5bbc 100644
--- a/src/js/jagex2/io/ClientStream.ts
+++ b/src/js/jagex2/io/ClientStream.ts
@@ -56,15 +56,15 @@ export default class ClientStream {
         return this.closed ? 0 : this.wsin.available;
     }
 
-    write = (src: Uint8Array, len: number): void => {
+    write(src: Uint8Array, len: number): void {
         this.wsout.write(src, len);
-    };
+    }
 
-    read = async (): Promise<number> => {
+    async read(): Promise<number> {
         return this.closed ? 0 : this.wsin.fastByte() ?? (await this.wsin.slowByte());
-    };
+    }
 
-    readBytes = async (dst: Uint8Array, off: number, len: number): Promise<void> => {
+    async readBytes(dst: Uint8Array, off: number, len: number): Promise<void> {
         if (this.closed) {
             return;
         }
@@ -76,9 +76,9 @@ export default class ClientStream {
             off += read.length;
             len -= read.length;
         }
-    };
+    }
 
-    close = (): void => {
+    close(): void {
         this.closed = true;
         this.socket.close();
         this.wsin.close();
@@ -87,7 +87,7 @@ export default class ClientStream {
         if (this.ioerror) {
             console.log('connection error!');
         }
-    };
+    }
 
     private onclose = (event: CloseEvent): void => {
         if (this.closed) {
@@ -118,7 +118,7 @@ class WebSocketWriter {
         this.limit = limit;
     }
 
-    write = (src: Uint8Array, len: number): void => {
+    write(src: Uint8Array, len: number): void {
         if (this.closed) {
             return;
         }
@@ -134,11 +134,11 @@ class WebSocketWriter {
         } catch (e) {
             this.ioerror = true;
         }
-    };
+    }
 
-    close = (): void => {
+    close(): void {
         this.closed = true;
-    };
+    }
 }
 
 class WebSocketEvent extends Linkable {
@@ -207,22 +207,22 @@ class WebSocketReader {
         }
     };
 
-    private readFastByte = (): number | null => {
+    private readFastByte(): number | null {
         if (this.event && this.event.available > 0) {
             return this.event.read;
         }
         return null;
-    };
+    }
 
-    private readSlowByte = async (len: number): Promise<number> => {
+    private async readSlowByte(len: number): Promise<number> {
         this.event = this.queue.removeHead() as WebSocketEvent | null;
         while (this.total < len) {
             await new Promise((resolve): ((value: PromiseLike<((data: WebSocketEvent | null) => void) | null>) => void) => (this.callback = resolve));
         }
         return this.event ? this.event.read : this.readSlowByte(len);
-    };
+    }
 
-    fastBytes = (dst: Uint8Array, off: number, len: number): Uint8Array | null => {
+    fastBytes(dst: Uint8Array, off: number, len: number): Uint8Array | null {
         if (this.closed) {
             throw new Error('WebSocketReader is closed!');
         }
@@ -239,9 +239,9 @@ class WebSocketReader {
             len--;
         }
         return dst;
-    };
+    }
 
-    slowBytes = async (dst: Uint8Array, off: number, len: number): Promise<Uint8Array> => {
+    async slowBytes(dst: Uint8Array, off: number, len: number): Promise<Uint8Array> {
         if (this.closed) {
             throw new Error('WebSocketReader is closed!');
         }
@@ -251,9 +251,9 @@ class WebSocketReader {
             len--;
         }
         return dst;
-    };
+    }
 
-    fastByte = (): number | null => {
+    fastByte(): number | null {
         if (this.closed) {
             throw new Error('WebSocketReader is closed!');
         }
@@ -263,22 +263,22 @@ class WebSocketReader {
         }
         this.total--;
         return fast;
-    };
+    }
 
-    slowByte = async (): Promise<number> => {
+    async slowByte(): Promise<number> {
         if (this.closed) {
             throw new Error('WebSocketReader is closed!');
         }
         const slow: number = await this.readSlowByte(1);
         this.total--;
         return slow;
-    };
+    }
 
-    close = (): void => {
+    close(): void {
         this.closed = true;
         this.callback = null;
         this.total = 0;
         this.event = null;
         this.queue.clear();
-    };
+    }
 }
diff --git a/src/js/jagex2/io/Isaac.ts b/src/js/jagex2/io/Isaac.ts
index 0efee085..7d0f9681 100644
--- a/src/js/jagex2/io/Isaac.ts
+++ b/src/js/jagex2/io/Isaac.ts
@@ -21,7 +21,7 @@ export default class Isaac {
         return this.rsl[this.count];
     }
 
-    private init = (): void => {
+    private init(): void {
         let a: number = 0x9e3779b9,
             b: number = 0x9e3779b9,
             c: number = 0x9e3779b9,
@@ -150,9 +150,9 @@ export default class Isaac {
 
         this.isaac();
         this.count = 256;
-    };
+    }
 
-    isaac = (): void => {
+    isaac(): void {
         this.c++;
         this.b += this.c;
 
@@ -176,5 +176,5 @@ export default class Isaac {
             this.mem[i] = y = this.mem[(x >>> 2) & 0xff] + this.a + this.b;
             this.rsl[i] = this.b = this.mem[((y >>> 8) >>> 2) & 0xff] + x;
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/io/Jagfile.ts b/src/js/jagex2/io/Jagfile.ts
index b4f2afe0..08778728 100644
--- a/src/js/jagex2/io/Jagfile.ts
+++ b/src/js/jagex2/io/Jagfile.ts
@@ -55,16 +55,16 @@ export default class Jagfile {
         }
     }
 
-    read = (name: string): Uint8Array | null => {
+    read(name: string): Uint8Array | null {
         const hash: number = Jagfile.genHash(name);
         const index: number = this.fileHash.indexOf(hash);
         if (index === -1) {
             return null;
         }
         return this.readIndex(index);
-    };
+    }
 
-    readIndex = (index: number): Uint8Array | null => {
+    readIndex(index: number): Uint8Array | null {
         if (index < 0 || index >= this.fileCount) {
             return null;
         }
@@ -84,5 +84,5 @@ export default class Jagfile {
             this.fileUnpacked[index] = data;
             return data;
         }
-    };
+    }
 }
diff --git a/src/js/jagex2/io/Packet.ts b/src/js/jagex2/io/Packet.ts
index 037c8aff..b43d0344 100644
--- a/src/js/jagex2/io/Packet.ts
+++ b/src/js/jagex2/io/Packet.ts
@@ -101,7 +101,7 @@ export default class Packet extends Hashable {
         return new Packet(new Uint8Array(30000));
     };
 
-    release = (): void => {
+    release(): void {
         this.pos = 0;
         if (this.data.length === 100 && Packet.cacheMinCount < 1000) {
             Packet.cacheMin.addTail(this);
@@ -113,7 +113,7 @@ export default class Packet extends Hashable {
             Packet.cacheMax.addTail(this);
             Packet.cacheMaxCount++;
         }
-    };
+    }
 
     get g1(): number {
         return this.data[this.pos++];
@@ -167,81 +167,81 @@ export default class Packet extends Hashable {
         return str;
     }
 
-    gdata = (length: number, offset: number, dest: Uint8Array | Int8Array): void => {
+    gdata(length: number, offset: number, dest: Uint8Array | Int8Array): void {
         for (let i: number = offset; i < offset + length; i++) {
             dest[i] = this.data[this.pos++];
         }
-    };
+    }
 
-    p1isaac = (opcode: number): void => {
+    p1isaac(opcode: number): void {
         this.data[this.pos++] = (opcode + (this.random?.nextInt ?? 0)) & 0xff;
-    };
+    }
 
-    p1 = (value: number): void => {
+    p1(value: number): void {
         this.data[this.pos++] = value;
-    };
+    }
 
-    p2 = (value: number): void => {
+    p2(value: number): void {
         this.data[this.pos++] = value >>> 8;
         this.data[this.pos++] = value;
-    };
+    }
 
-    ip2 = (value: number): void => {
+    ip2(value: number): void {
         this.data[this.pos++] = value;
         this.data[this.pos++] = value >>> 8;
-    };
+    }
 
-    p3 = (value: number): void => {
+    p3(value: number): void {
         this.data[this.pos++] = value >>> 16;
         this.data[this.pos++] = value >>> 8;
         this.data[this.pos++] = value;
-    };
+    }
 
-    p4 = (value: number): void => {
+    p4(value: number): void {
         this.data[this.pos++] = value >>> 24;
         this.data[this.pos++] = value >>> 16;
         this.data[this.pos++] = value >>> 8;
         this.data[this.pos++] = value;
-    };
+    }
 
-    ip4 = (value: number): void => {
+    ip4(value: number): void {
         this.data[this.pos++] = value;
         this.data[this.pos++] = value >>> 8;
         this.data[this.pos++] = value >>> 16;
         this.data[this.pos++] = value >>> 24;
-    };
+    }
 
-    p8 = (value: bigint): void => {
+    p8(value: bigint): void {
         this.p4(Number(value >> 32n));
         this.p4(Number(value & 0xffffffffn));
-    };
+    }
 
-    pjstr = (str: string): void => {
+    pjstr(str: string): void {
         for (let i: number = 0; i < str.length; i++) {
             this.data[this.pos++] = str.charCodeAt(i);
         }
         this.data[this.pos++] = 10;
-    };
+    }
 
-    pdata = (src: Uint8Array, length: number, offset: number): void => {
+    pdata(src: Uint8Array, length: number, offset: number): void {
         for (let i: number = offset; i < offset + length; i++) {
             this.data[this.pos++] = src[i];
         }
-    };
+    }
 
-    psize1 = (size: number): void => {
+    psize1(size: number): void {
         this.data[this.pos - size - 1] = size;
-    };
+    }
 
-    bits = (): void => {
+    bits(): void {
         this.bitPos = this.pos * 8;
-    };
+    }
 
-    bytes = (): void => {
+    bytes(): void {
         this.pos = ((this.bitPos + 7) / 8) | 0;
-    };
+    }
 
-    gBit = (n: number): number => {
+    gBit(n: number): number {
         let bytePos: number = this.bitPos >>> 3;
         let remaining: number = 8 - (this.bitPos & 7);
         let value: number = 0;
@@ -259,9 +259,9 @@ export default class Packet extends Hashable {
         }
 
         return value;
-    };
+    }
 
-    rsaenc = (mod: bigint, exp: bigint): void => {
+    rsaenc(mod: bigint, exp: bigint): void {
         const temp: Uint8Array = new Uint8Array(this.pos);
         arraycopy(this.data, 0, temp, 0, this.pos);
 
@@ -272,5 +272,5 @@ export default class Packet extends Hashable {
         this.pos = 0;
         this.p1(rawEnc.length);
         this.pdata(rawEnc, rawEnc.length, 0);
-    };
+    }
 }
diff --git a/src/js/jagex2/sound/SoundEnvelope.ts b/src/js/jagex2/sound/SoundEnvelope.ts
index b6fa419f..f8013086 100644
--- a/src/js/jagex2/sound/SoundEnvelope.ts
+++ b/src/js/jagex2/sound/SoundEnvelope.ts
@@ -14,7 +14,7 @@ export default class SoundEnvelope {
     private amplitude: number = 0;
     private ticks: number = 0;
 
-    read = (dat: Packet): void => {
+    read(dat: Packet): void {
         this.form = dat.g1;
         this.start = dat.g4;
         this.end = dat.g4;
@@ -26,17 +26,17 @@ export default class SoundEnvelope {
             this.shapeDelta[i] = dat.g2;
             this.shapePeak[i] = dat.g2;
         }
-    };
+    }
 
-    reset = (): void => {
+    reset(): void {
         this.threshold = 0;
         this.position = 0;
         this.delta = 0;
         this.amplitude = 0;
         this.ticks = 0;
-    };
+    }
 
-    evaluate = (delta: number): number => {
+    evaluate(delta: number): number {
         if (this.ticks >= this.threshold && this.shapePeak && this.shapeDelta) {
             this.amplitude = this.shapePeak[this.position++] << 15;
 
@@ -53,5 +53,5 @@ export default class SoundEnvelope {
         this.amplitude += this.delta;
         this.ticks++;
         return (this.amplitude - this.delta) >> 15;
-    };
+    }
 }
diff --git a/src/js/jagex2/sound/SoundTone.ts b/src/js/jagex2/sound/SoundTone.ts
index 4f2edbf4..89f91612 100644
--- a/src/js/jagex2/sound/SoundTone.ts
+++ b/src/js/jagex2/sound/SoundTone.ts
@@ -48,7 +48,7 @@ export default class SoundTone {
         this.buffer = new Int32Array(220500); // 10s * 22050 KHz
     };
 
-    generate = (sampleCount: number, length: number): Int32Array => {
+    generate(sampleCount: number, length: number): Int32Array {
         for (let sample: number = 0; sample < sampleCount; sample++) {
             SoundTone.buffer![sample] = 0;
         }
@@ -175,9 +175,9 @@ export default class SoundTone {
         }
 
         return SoundTone.buffer!;
-    };
+    }
 
-    generate2 = (amplitude: number, phase: number, form: number): number => {
+    generate2(amplitude: number, phase: number, form: number): number {
         if (form === 1) {
             return (phase & 0x7fff) < 16384 ? amplitude : -amplitude;
         } else if (form === 2) {
@@ -189,9 +189,9 @@ export default class SoundTone {
         } else {
             return 0;
         }
-    };
+    }
 
-    read = (dat: Packet): void => {
+    read(dat: Packet): void {
         this.frequencyBase = new SoundEnvelope();
         this.frequencyBase.read(dat);
 
@@ -243,5 +243,5 @@ export default class SoundTone {
         this.reverbVolume = dat.gsmarts;
         this.length = dat.g2;
         this.start = dat.g2;
-    };
+    }
 }
diff --git a/src/js/jagex2/sound/Wave.ts b/src/js/jagex2/sound/Wave.ts
index b161ad0d..b0bd719a 100644
--- a/src/js/jagex2/sound/Wave.ts
+++ b/src/js/jagex2/sound/Wave.ts
@@ -42,7 +42,7 @@ export default class Wave {
         return track?.getWave(loopCount) ?? null;
     };
 
-    read = (dat: Packet): void => {
+    read(dat: Packet): void {
         for (let tone: number = 0; tone < 10; tone++) {
             if (dat.g1 !== 0) {
                 dat.pos--;
@@ -52,9 +52,9 @@ export default class Wave {
         }
         this.loopBegin = dat.g2;
         this.loopEnd = dat.g2;
-    };
+    }
 
-    trim = (): number => {
+    trim(): number {
         let start: number = 9999999;
         for (let tone: number = 0; tone < 10; tone++) {
             if (this.tones[tone] && ((this.tones[tone]!.start / 20) | 0) < start) {
@@ -82,9 +82,9 @@ export default class Wave {
         }
 
         return start;
-    };
+    }
 
-    getWave = (loopCount: number): Packet | null => {
+    getWave(loopCount: number): Packet | null {
         const length: number = this.generate(loopCount);
         Wave.waveBuffer!.pos = 0;
         Wave.waveBuffer?.p4(0x52494646); // "RIFF" ChunkID
@@ -102,9 +102,9 @@ export default class Wave {
         Wave.waveBuffer?.ip4(length);
         Wave.waveBuffer!.pos += length;
         return Wave.waveBuffer;
-    };
+    }
 
-    private generate = (loopCount: number): number => {
+    private generate(loopCount: number): number {
         let duration: number = 0;
         for (let tone: number = 0; tone < 10; tone++) {
             if (this.tones[tone] && this.tones[tone]!.length + this.tones[tone]!.start > duration) {
@@ -171,5 +171,5 @@ export default class Wave {
         }
 
         return totalSampleCount;
-    };
+    }
 }
diff --git a/src/js/jagex2/util/JavaRandom.ts b/src/js/jagex2/util/JavaRandom.ts
index 98d3f940..43948ba8 100644
--- a/src/js/jagex2/util/JavaRandom.ts
+++ b/src/js/jagex2/util/JavaRandom.ts
@@ -5,16 +5,16 @@ export default class JavaRandom {
         this.seed = (seed ^ 0x5deece66dn) & ((1n << 48n) - 1n);
     }
 
-    setSeed = (seed: bigint): void => {
+    setSeed(seed: bigint): void {
         this.seed = (seed ^ 0x5deece66dn) & ((1n << 48n) - 1n);
-    };
+    }
 
-    nextInt = (): number => {
+    nextInt(): number {
         return this.next(32);
-    };
+    }
 
-    next = (bits: number): number => {
+    next(bits: number): number {
         this.seed = (this.seed * 0x5deece66dn + 0xbn) & ((1n << 48n) - 1n);
         return Number(this.seed) >>> (48 - bits);
-    };
+    }
 }
diff --git a/src/js/jagex2/util/JsUtil.ts b/src/js/jagex2/util/JsUtil.ts
index 6cf0dcf9..02292aaf 100644
--- a/src/js/jagex2/util/JsUtil.ts
+++ b/src/js/jagex2/util/JsUtil.ts
@@ -2,28 +2,28 @@ export const sleep = async (ms: number): Promise<void> => new Promise((resolve):
 export const downloadUrl = async (url: string): Promise<Int8Array> => new Int8Array(await (await fetch(url)).arrayBuffer());
 export const downloadText = async (url: string): Promise<string> => (await fetch(url)).text();
 
-export const arraycopy = (src: Int32Array | Uint8Array, srcPos: number, dst: Int32Array | Uint8Array, dstPos: number, length: number): void => {
+export function arraycopy(src: Int32Array | Uint8Array, srcPos: number, dst: Int32Array | Uint8Array, dstPos: number, length: number): void {
     while (length--) dst[dstPos++] = src[srcPos++];
-};
+}
 
-export const bytesToBigInt = (bytes: Uint8Array): bigint => {
+export function bytesToBigInt(bytes: Uint8Array): bigint {
     let result: bigint = 0n;
     for (let index: number = 0; index < bytes.length; index++) {
         result = (result << 8n) + BigInt(bytes[index]);
     }
     return result;
-};
+}
 
-export const bigIntToBytes = (bigInt: bigint): Uint8Array => {
+export function bigIntToBytes(bigInt: bigint): Uint8Array {
     const byteArray: number[] = [];
     while (bigInt > 0n) {
         byteArray.unshift(Number(bigInt & 255n));
         bigInt >>= 8n;
     }
     return new Uint8Array(byteArray);
-};
+}
 
-export const bigIntModPow = (base: bigint, exponent: bigint, modulus: bigint): bigint => {
+export function bigIntModPow(base: bigint, exponent: bigint, modulus: bigint): bigint {
     let result: bigint = 1n;
     while (exponent > 0n) {
         if (exponent % 2n === 1n) {
@@ -33,4 +33,4 @@ export const bigIntModPow = (base: bigint, exponent: bigint, modulus: bigint): b
         exponent >>= 1n;
     }
     return result;
-};
+}