@lordbex/thelounge 4.4.4-blowfish → 4.5.1-blowfish

package/dist/server/client.js

@@ -1,50 +1,23 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
-const ua_parser_js_1 = __importDefault(require("ua-parser-js"));
-const uuid_1 = require("uuid");
-const escapeRegExp_1 = __importDefault(require("lodash/escapeRegExp"));
-const crypto_1 = __importDefault(require("crypto"));
-const chalk_1 = __importDefault(require("chalk"));
-const log_1 = __importDefault(require("./log"));
-const chan_1 = __importDefault(require("./models/chan"));
-const msg_1 = __importDefault(require("./models/msg"));
-const config_1 = __importDefault(require("./config"));
-const irc_1 = require("../shared/irc");
-const msg_2 = require("../shared/types/msg");
-const inputs_1 = __importDefault(require("./plugins/inputs"));
-const publicClient_1 = __importDefault(require("./plugins/packages/publicClient"));
-const sqlite_1 = __importDefault(require("./plugins/messageStorage/sqlite"));
-const text_1 = __importDefault(require("./plugins/messageStorage/text"));
-const network_1 = __importDefault(require("./models/network"));
-const storageCleaner_1 = require("./storageCleaner");
-const chan_2 = require("../shared/types/chan");
+import _ from "lodash";
+import { UAParser } from "ua-parser-js";
+import { v4 as uuidv4 } from "uuid";
+import escapeRegExp from "lodash/escapeRegExp.js";
+import crypto from "crypto";
+import colors from "chalk";
+import log from "./log.js";
+import Chan from "./models/chan.js";
+import Msg from "./models/msg.js";
+import Config from "./config.js";
+import { condensedTypes } from "../shared/irc.js";
+import { MessageType } from "../shared/types/msg.js";
+import inputs from "./plugins/inputs/index.js";
+import PublicClient from "./plugins/packages/publicClient.js";
+import SqliteMessageStorage from "./plugins/messageStorage/sqlite.js";
+import TextFileMessageStorage from "./plugins/messageStorage/text.js";
+import Network from "./models/network.js";
+import { StorageCleaner } from "./storageCleaner.js";
+import { ChanType } from "../shared/types/chan.js";
+import MassEventAggregator from "./plugins/massEventAggregator.js";
 const events = [
     "away",
     "cap",
@@ -68,6 +41,8 @@ const events = [
     "part",
     "quit",
     "sasl",
+    "spgroups",
+    "spjoin",
     "topic",
     "welcome",
     "whois",
@@ -88,10 +63,11 @@ class Client {
     highlightRegex;
     highlightExceptionRegex;
     messageProvider;
+    massEventAggregator;
     fileHash;
     constructor(manager, name, config = {}) {
-        this.id = (0, uuid_1.v4)();
-        lodash_1.default.merge(this, {
+        this.id = uuidv4();
+        _.merge(this, {
             awayMessage: "",
             lastActiveChannel: -1,
             attachedClients: {},
@@ -107,74 +83,74 @@ class Client {
             highlightExceptionRegex: null,
             messageProvider: undefined,
         });
-        const client = this;
-        client.config.log = Boolean(client.config.log);
-        client.config.password = String(client.config.password);
-        if (!config_1.default.values.public && client.config.log) {
-            if (config_1.default.values.messageStorage.includes("sqlite")) {
-                client.messageProvider = new sqlite_1.default(client.name);
-                if (config_1.default.values.storagePolicy.enabled) {
-                    log_1.default.info(`Activating storage cleaner. Policy: ${config_1.default.values.storagePolicy.deletionPolicy}. MaxAge: ${config_1.default.values.storagePolicy.maxAgeDays} days`);
-                    const cleaner = new storageCleaner_1.StorageCleaner(client.messageProvider);
+        this.config.log = Boolean(this.config.log);
+        this.config.password = String(this.config.password);
+        // Initialize mass event aggregator for handling netsplits/mass reconnects
+        this.massEventAggregator = new MassEventAggregator(this);
+        if (!Config.values.public && this.config.log) {
+            if (Config.values.messageStorage.includes("sqlite")) {
+                this.messageProvider = new SqliteMessageStorage(this.name);
+                if (Config.values.storagePolicy.enabled) {
+                    log.info(`Activating storage cleaner. Policy: ${Config.values.storagePolicy.deletionPolicy}. MaxAge: ${Config.values.storagePolicy.maxAgeDays} days`);
+                    const cleaner = new StorageCleaner(this.messageProvider);
                     cleaner.start();
                 }
-                client.messageStorage.push(client.messageProvider);
+                this.messageStorage.push(this.messageProvider);
             }
-            if (config_1.default.values.messageStorage.includes("text")) {
-                client.messageStorage.push(new text_1.default(client.name));
+            if (Config.values.messageStorage.includes("text")) {
+                this.messageStorage.push(new TextFileMessageStorage(this.name));
             }
-            for (const messageStorage of client.messageStorage) {
-                messageStorage.enable().catch((e) => log_1.default.error(e));
+            for (const messageStorage of this.messageStorage) {
+                messageStorage.enable().catch((e) => log.error(e));
             }
         }
-        if (!lodash_1.default.isPlainObject(client.config.sessions)) {
-            client.config.sessions = {};
+        if (!_.isPlainObject(this.config.sessions)) {
+            this.config.sessions = {};
         }
-        if (!lodash_1.default.isPlainObject(client.config.clientSettings)) {
-            client.config.clientSettings = {};
+        if (!_.isPlainObject(this.config.clientSettings)) {
+            this.config.clientSettings = {};
         }
-        if (!lodash_1.default.isPlainObject(client.config.browser)) {
-            client.config.browser = {};
+        if (!_.isPlainObject(this.config.browser)) {
+            this.config.browser = {};
         }
-        if (client.config.clientSettings.awayMessage) {
-            client.awayMessage = client.config.clientSettings.awayMessage;
+        if (this.config.clientSettings.awayMessage) {
+            this.awayMessage = this.config.clientSettings.awayMessage;
         }
-        client.config.clientSettings.searchEnabled = client.messageProvider !== undefined;
-        client.compileCustomHighlights();
-        lodash_1.default.forOwn(client.config.sessions, (session) => {
+        this.config.clientSettings.searchEnabled = this.messageProvider !== undefined;
+        this.compileCustomHighlights();
+        _.forOwn(this.config.sessions, (session) => {
             if (session.pushSubscription) {
                 this.registerPushSubscription(session, session.pushSubscription, true);
             }
         });
     }
     connect() {
-        const client = this;
-        if (client.networks.length !== 0) {
-            throw new Error(`${client.name} is already connected`);
+        if (this.networks.length !== 0) {
+            throw new Error(`${this.name} is already connected`);
         }
-        (client.config.networks || []).forEach((network) => client.connectToNetwork(network, true));
+        (this.config.networks || []).forEach((network) => this.connectToNetwork(network, true));
         // Networks are stored directly in the client object
         // We don't need to keep it in the config object
-        delete client.config.networks;
-        if (client.name) {
-            log_1.default.info(`User ${chalk_1.default.bold(client.name)} loaded`);
+        delete this.config.networks;
+        if (this.name) {
+            log.info(`User ${colors.bold(this.name)} loaded`);
             // Networks are created instantly, but to reduce server load on startup
             // We randomize the IRC connections and channel log loading
-            let delay = client.manager.clients.length * 500;
-            client.networks.forEach((network) => {
+            let delay = this.manager.clients.length * 500;
+            this.networks.forEach((network) => {
                 setTimeout(() => {
-                    network.channels.forEach((channel) => channel.loadMessages(client, network));
+                    network.channels.forEach((channel) => channel.loadMessages(this, network));
                     if (!network.userDisconnected && network.irc) {
                         network.irc.connect();
                     }
                 }, delay);
                 delay += 1000 + Math.floor(Math.random() * 1000);
             });
-            client.fileHash = client.manager.getDataToSave(client).newHash;
+            this.fileHash = this.manager.getDataToSave(this).newHash;
         }
     }
     createChannel(attr) {
-        const chan = new chan_1.default(attr);
+        const chan = new Chan(attr);
         chan.id = this.idChan++;
         return chan;
     }
@@ -187,7 +163,7 @@ class Client {
         let network = null;
         let chan = null;
         for (const n of this.networks) {
-            chan = lodash_1.default.find(n.channels, { id: channelId });
+            chan = _.find(n.channels, { id: channelId });
             if (chan) {
                 network = n;
                 break;
@@ -199,100 +175,100 @@ class Client {
         return false;
     }
     networkFromConfig(args) {
-        const client = this;
         let channels = [];
         if (Array.isArray(args.channels)) {
             let badChanConf = false;
             args.channels.forEach((chan) => {
-                const type = chan_2.ChanType[(chan.type || "channel").toUpperCase()];
+                const type = ChanType[(chan.type || "channel").toUpperCase()];
                 if (!chan.name || !type) {
                     badChanConf = true;
                     return;
                 }
-                channels.push(client.createChannel({
+                channels.push(this.createChannel({
                     name: chan.name,
                     key: chan.key || "",
                     type: type,
                     muted: chan.muted,
+                    pinned: chan.pinned,
                 }));
             });
-            if (badChanConf && client.name) {
-                log_1.default.warn("User '" +
-                    client.name +
+            if (badChanConf && this.name) {
+                log.warn("User '" +
+                    this.name +
                     "' on network '" +
-                    String(args.name) +
+                    (args.name || "") +
                     "' has an invalid channel which has been ignored");
             }
             // `join` is kept for backwards compatibility when updating from versions <2.0
             // also used by the "connect" window
         }
         else if (args.join) {
-            channels = args.join
+            channels = (args.join || "")
                 .replace(/,/g, " ")
                 .split(/\s+/g)
                 .map((chan) => {
                 if (!chan.match(/^[#&!+]/)) {
                     chan = `#${chan}`;
                 }
-                return client.createChannel({
+                return this.createChannel({
                     name: chan,
                 });
             });
         }
-        // TODO; better typing for args
-        return new network_1.default({
+        // Handle commands - can be string[] or string
+        const commands = Array.isArray(args.commands) ? args.commands : [];
+        return new Network({
             uuid: args.uuid,
-            name: String(args.name || (config_1.default.values.lockNetwork ? config_1.default.values.defaults.name : "") || ""),
-            host: String(args.host || ""),
-            port: parseInt(String(args.port), 10),
+            name: args.name || (Config.values.lockNetwork ? Config.values.defaults.name : "") || "",
+            host: args.host || "",
+            port: parseInt(String(args.port ?? 6667), 10),
             tls: !!args.tls,
             userDisconnected: !!args.userDisconnected,
             rejectUnauthorized: !!args.rejectUnauthorized,
-            password: String(args.password || ""),
-            nick: String(args.nick || ""),
-            username: String(args.username || ""),
-            realname: String(args.realname || ""),
-            leaveMessage: String(args.leaveMessage || ""),
-            sasl: String(args.sasl || ""),
-            saslAccount: String(args.saslAccount || ""),
-            saslPassword: String(args.saslPassword || ""),
-            commands: args.commands || [],
+            password: args.password || "",
+            nick: args.nick || "",
+            username: args.username || "",
+            realname: args.realname || "",
+            leaveMessage: args.leaveMessage || "",
+            sasl: args.sasl || "",
+            saslAccount: args.saslAccount || "",
+            saslPassword: args.saslPassword || "",
+            commands: commands,
             channels: channels,
-            ignoreList: args.ignoreList ? args.ignoreList : [],
+            ignoreList: args.ignoreList || [],
             proxyEnabled: !!args.proxyEnabled,
-            proxyHost: String(args.proxyHost || ""),
-            proxyPort: parseInt(args.proxyPort, 10),
-            proxyUsername: String(args.proxyUsername || ""),
-            proxyPassword: String(args.proxyPassword || ""),
+            proxyHost: args.proxyHost || "",
+            proxyPort: parseInt(String(args.proxyPort ?? 1080), 10),
+            proxyUsername: args.proxyUsername || "",
+            proxyPassword: args.proxyPassword || "",
             fishGlobalKey: String(args.fishGlobalKey || ""),
             fishKeys: args.fishKeys || {},
         });
     }
     connectToNetwork(args, isStartup = false) {
-        const client = this;
         // Get channel id for lobby before creating other channels for nicer ids
-        const lobbyChannelId = client.idChan++;
+        const lobbyChannelId = this.idChan++;
         const network = this.networkFromConfig(args);
         // Set network lobby channel id
         network.getLobby().id = lobbyChannelId;
-        client.networks.push(network);
-        client.emit("network", {
+        this.networks.push(network);
+        this.emit("network", {
             network: network.getFilteredClone(this.lastActiveChannel, -1),
         });
-        if (!network.validate(client)) {
+        if (!network.validate(this)) {
             return;
         }
-        network.createIrcFramework(client);
+        network.createIrcFramework(this);
         // TODO
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
         events.forEach(async (plugin) => {
-            (await Promise.resolve(`${`./plugins/irc-events/${plugin}`}`).then(s => __importStar(require(s)))).default.apply(client, [
+            (await import(`./plugins/irc-events/${plugin}.js`)).default.apply(this, [
                 network.irc,
                 network,
             ]);
         });
         if (network.userDisconnected) {
-            network.getLobby().pushMessage(client, new msg_1.default({
+            network.getLobby().pushMessage(this, new Msg({
                 text: "You have manually disconnected from this network before, use the /connect command to connect again.",
             }), true);
         }
@@ -302,12 +278,12 @@ class Client {
             network.irc.connect();
         }
         if (!isStartup) {
-            client.save();
-            network.channels.forEach((channel) => channel.loadMessages(client, network));
+            this.save();
+            network.channels.forEach((channel) => channel.loadMessages(this, network));
         }
     }
     generateToken(callback) {
-        crypto_1.default.randomBytes(64, (err, buf) => {
+        crypto.randomBytes(64, (err, buf) => {
             if (err) {
                 throw err;
             }
@@ -315,11 +291,12 @@ class Client {
         });
     }
     calculateTokenHash(token) {
-        return crypto_1.default.createHash("sha512").update(token).digest("hex");
+        return crypto.createHash("sha512").update(token).digest("hex");
     }
     updateSession(token, ip, request) {
-        const client = this;
-        const agent = (0, ua_parser_js_1.default)(request.headers["user-agent"] || "");
+        const userAgent = request.headers["user-agent"];
+        const parser = new UAParser(typeof userAgent === "string" ? userAgent : "");
+        const agent = parser.getResult();
         let friendlyAgent = "";
         if (agent.browser.name) {
             friendlyAgent = `${agent.browser.name} ${agent.browser.major || ""}`;
@@ -333,36 +310,33 @@ class Client {
                 friendlyAgent += ` ${agent.os.version}`;
             }
         }
-        client.config.sessions[token] = lodash_1.default.assign(client.config.sessions[token], {
+        this.config.sessions[token] = _.assign(this.config.sessions[token], {
             lastUse: Date.now(),
             ip: ip,
             agent: friendlyAgent,
         });
-        client.save();
+        this.save();
     }
     setPassword(hash, callback) {
-        const client = this;
-        const oldHash = client.config.password;
-        client.config.password = hash;
-        client.manager.saveUser(client, function (err) {
+        const oldHash = this.config.password;
+        this.config.password = hash;
+        this.manager.saveUser(this, (err) => {
             if (err) {
                 // If user file fails to write, reset it back
-                client.config.password = oldHash;
+                this.config.password = oldHash;
                 return callback(false);
             }
             return callback(true);
         });
     }
     input(data) {
-        const client = this;
         data.text.split("\n").forEach((line) => {
             data.text = line;
-            client.inputLine(data);
+            this.inputLine(data);
         });
     }
     inputLine(data) {
-        const client = this;
-        const target = client.find(data.target);
+        const target = this.find(data.target);
         if (!target) {
             return;
         }
@@ -372,9 +346,9 @@ class Client {
         let text = data.text;
         // This is either a normal message or a command escaped with a leading '/'
         if (text.charAt(0) !== "/" || text.charAt(1) === "/") {
-            if (target.chan.type === chan_2.ChanType.LOBBY) {
-                target.chan.pushMessage(this, new msg_1.default({
-                    type: msg_2.MessageType.ERROR,
+            if (target.chan.type === ChanType.LOBBY) {
+                target.chan.pushMessage(this, new Msg({
+                    type: MessageType.ERROR,
                     text: "Messages can not be sent to lobbies.",
                 }));
                 return;
@@ -389,27 +363,27 @@ class Client {
         const irc = target.network.irc;
         const connected = irc?.connected;
         const emitFailureDisconnected = () => {
-            target.chan.pushMessage(this, new msg_1.default({
-                type: msg_2.MessageType.ERROR,
+            target.chan.pushMessage(this, new Msg({
+                type: MessageType.ERROR,
                 text: "You are not connected to the IRC network, unable to send your command.",
             }));
         };
-        const plugin = inputs_1.default.userInputs.get(cmd);
+        const plugin = inputs.userInputs.get(cmd);
         if (plugin) {
             if (!connected && !plugin.allowDisconnected) {
                 emitFailureDisconnected();
                 return;
             }
-            plugin.input.apply(client, [target.network, target.chan, cmd, args]);
+            plugin.input.apply(this, [target.network, target.chan, cmd, args]);
             return;
         }
-        const extPlugin = inputs_1.default.pluginCommands.get(cmd);
+        const extPlugin = inputs.pluginCommands.get(cmd);
         if (extPlugin) {
             if (!connected && !extPlugin.allowDisconnected) {
                 emitFailureDisconnected();
                 return;
             }
-            extPlugin.input(new publicClient_1.default(client, extPlugin.packageInfo), { network: target.network, chan: target.chan }, cmd, args);
+            extPlugin.input(new PublicClient(this, extPlugin.packageInfo), { network: target.network, chan: target.chan }, cmd, args);
             return;
         }
         if (!connected) {
@@ -427,7 +401,7 @@ class Client {
             // Ensure we don't have empty strings in the list of highlights
             const highlightsTokens = customHighlightString
                 .split(",")
-                .map((highlight) => (0, escapeRegExp_1.default)(highlight.trim()))
+                .map((highlight) => escapeRegExp(highlight.trim()))
                 .filter((highlight) => highlight.length > 0);
             if (highlightsTokens.length === 0) {
                 return null;
@@ -438,15 +412,20 @@ class Client {
         this.highlightExceptionRegex = compileHighlightRegex(this.config.clientSettings.highlightExceptions);
     }
     more(data) {
-        const client = this;
-        const target = client.find(data.target);
+        const target = this.find(data.target);
         if (!target) {
             return null;
         }
         const chan = target.chan;
         let messages = [];
         let index = 0;
-        // If client requests -1, send last 100 messages
+        const enhancedSearch = Boolean(this.config.clientSettings.searchEnabled &&
+            this.config.clientSettings.enableEnhancedSearch);
+        // Use batch sizes for "more" requests, batch sizes are based on enableEnhancedSearch setting
+        // When enableEnhancedSearch = true send upto 10000 messages at a time
+        const batchSize = enhancedSearch ? 1000 : 100;
+        const maxBatchSize = enhancedSearch ? 10000 : 1000;
+        // If client requests -1, send last batch of messages
         if (data.lastId < 0) {
             index = chan.messages.length;
         }
@@ -457,23 +436,23 @@ class Client {
         if (index > 0) {
             let startIndex = index;
             if (data.condensed) {
-                // Limit to 1000 messages (that's 10x normal limit)
-                const indexToStop = Math.max(0, index - 1000);
-                let realMessagesLeft = 100;
+                // Limit to maxBatchSize messages when condensed
+                const indexToStop = Math.max(0, index - maxBatchSize);
+                let realMessagesLeft = batchSize;
                 for (let i = index - 1; i >= indexToStop; i--) {
                     startIndex--;
-                    // Do not count condensed messages towards the 100 messages
-                    if (irc_1.condensedTypes.has(chan.messages[i].type)) {
+                    // Do not count condensed messages towards the batch
+                    if (condensedTypes.has(chan.messages[i].type)) {
                         continue;
                     }
-                    // Count up actual 100 visible messages
+                    // Count up actual visible messages
                     if (--realMessagesLeft === 0) {
                         break;
                     }
                 }
             }
             else {
-                startIndex = Math.max(0, index - 100);
+                startIndex = Math.max(0, index - batchSize);
             }
             messages = chan.messages.slice(startIndex, index);
         }
@@ -484,8 +463,7 @@ class Client {
         };
     }
     clearHistory(data) {
-        const client = this;
-        const target = client.find(data.target);
+        const target = this.find(data.target);
         if (!target) {
             return;
         }
@@ -493,14 +471,14 @@ class Client {
         target.chan.unread = 0;
         target.chan.highlight = 0;
         target.chan.firstUnread = 0;
-        client.emit("history:clear", {
+        this.emit("history:clear", {
             target: target.chan.id,
         });
         if (!target.chan.isLoggable()) {
             return;
         }
         for (const messageStorage of this.messageStorage) {
-            messageStorage.deleteChannel(target.network, target.chan).catch((e) => log_1.default.error(e));
+            messageStorage.deleteChannel(target.network, target.chan).catch((e) => log.error(e));
         }
     }
     async search(query) {
@@ -512,6 +490,28 @@ class Client {
         }
         return this.messageProvider.search(query);
     }
+    async getMessagesAround(data) {
+        const target = this.find(data.target);
+        if (!target) {
+            return null;
+        }
+        const chan = target.chan;
+        const network = target.network;
+        if (!this.messageProvider?.isEnabled) {
+            return null;
+        }
+        try {
+            const messages = await this.messageProvider.getMessagesAround(network.uuid, chan.name, data.time, 200);
+            return {
+                chan: chan.id,
+                messages: messages,
+            };
+        }
+        catch (err) {
+            log.error("Failed to get messages around time:", String(err));
+            return null;
+        }
+    }
     open(socketId, target) {
         // Due to how socket.io works internally, normal events may arrive later than
         // the disconnect event, and because we can't control this timing precisely,
@@ -538,17 +538,17 @@ class Client {
         this.emit("open", targetNetChan.chan.id);
     }
     sortChannels(netid, order) {
-        const network = lodash_1.default.find(this.networks, { uuid: netid });
+        const network = _.find(this.networks, { uuid: netid });
         if (!network) {
             return;
         }
         network.channels.sort((a, b) => {
             // Always sort lobby to the top regardless of what the client has sent
             // Because there's a lot of code that presumes channels[0] is the lobby
-            if (a.type === chan_2.ChanType.LOBBY) {
+            if (a.type === ChanType.LOBBY) {
                 return -1;
             }
-            else if (b.type === chan_2.ChanType.LOBBY) {
+            else if (b.type === ChanType.LOBBY) {
                 return 1;
             }
             return order.indexOf(a.id) - order.indexOf(b.id);
@@ -569,23 +569,21 @@ class Client {
         });
     }
     names(data) {
-        const client = this;
-        const target = client.find(data.target);
+        const target = this.find(data.target);
         if (!target) {
             return;
         }
-        client.emit("names", {
+        this.emit("names", {
             id: target.chan.id,
             users: target.chan.getSortedUsers(target.network.irc),
         });
     }
     part(network, chan) {
-        const client = this;
-        network.channels = lodash_1.default.without(network.channels, chan);
-        client.mentions = client.mentions.filter((msg) => !(msg.chanId === chan.id));
+        network.channels = _.without(network.channels, chan);
+        this.mentions = this.mentions.filter((msg) => !(msg.chanId === chan.id));
         chan.destroy();
-        client.save();
-        client.emit("part", {
+        this.save();
+        this.emit("part", {
             chan: chan.id,
         });
     }
@@ -608,13 +606,12 @@ class Client {
             network.destroy();
         });
         for (const messageStorage of this.messageStorage) {
-            messageStorage.close().catch((e) => log_1.default.error(e));
+            messageStorage.close().catch((e) => log.error(e));
         }
     }
     clientAttach(socketId, token) {
-        const client = this;
-        if (client.awayMessage && lodash_1.default.size(client.attachedClients) === 0) {
-            client.networks.forEach(function (network) {
+        if (this.awayMessage && _.size(this.attachedClients) === 0) {
+            this.networks.forEach((network) => {
                 // Only remove away on client attachment if
                 // there is no away message on this network
                 if (network.irc && !network.awayMessage) {
@@ -622,32 +619,30 @@ class Client {
                 }
             });
         }
-        const openChannel = client.lastActiveChannel;
-        client.attachedClients[socketId] = { token, openChannel };
+        const openChannel = this.lastActiveChannel;
+        this.attachedClients[socketId] = { token, openChannel };
     }
     clientDetach(socketId) {
-        const client = this;
         delete this.attachedClients[socketId];
-        if (client.awayMessage && lodash_1.default.size(client.attachedClients) === 0) {
-            client.networks.forEach(function (network) {
+        if (this.awayMessage && _.size(this.attachedClients) === 0) {
+            this.networks.forEach((network) => {
                 // Only set away on client deattachment if
                 // there is no away message on this network
                 if (network.irc && !network.awayMessage) {
-                    network.irc.raw("AWAY", client.awayMessage);
+                    network.irc.raw("AWAY", this.awayMessage);
                 }
             });
         }
     }
-    // TODO: type session to this.attachedClients
     registerPushSubscription(session, subscription, noSave = false) {
-        if (!lodash_1.default.isPlainObject(subscription) ||
+        if (!_.isPlainObject(subscription) ||
             typeof subscription.endpoint !== "string" ||
             !/^https?:\/\//.test(subscription.endpoint) ||
-            !lodash_1.default.isPlainObject(subscription.keys) ||
+            !_.isPlainObject(subscription.keys) ||
             !subscription.keys || // TS compiler doesn't understand isPlainObject
             typeof subscription.keys.p256dh !== "string" ||
             typeof subscription.keys.auth !== "string") {
-            session.pushSubscription = null;
+            session.pushSubscription = undefined;
             return;
         }
         const data = {
@@ -667,12 +662,11 @@ class Client {
         this.config.sessions[token].pushSubscription = undefined;
         this.save();
     }
-    save = lodash_1.default.debounce(function SaveClient() {
-        if (config_1.default.values.public) {
+    save = _.debounce(function SaveClient() {
+        if (Config.values.public) {
             return;
         }
-        const client = this;
-        client.manager.saveUser(client);
+        this.manager.saveUser(this);
     }, 5000, { maxWait: 20000 });
 }
-exports.default = Client;
+export default Client;