@lordbex/thelounge 4.4.4-blowfish → 4.5.0-blowfish-pre

package/dist/server/plugins/messageStorage/text.js

@@ -1,14 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-const filenamify_1 = __importDefault(require("filenamify"));
-const config_1 = __importDefault(require("../../config"));
-const msg_1 = require("../../../shared/types/msg");
+import fs from "fs/promises";
+import path from "path";
+import filenamify from "filenamify";
+import Config from "../../config.js";
+import { MessageType } from "../../../shared/types/msg.js";
 class TextFileMessageStorage {
     isEnabled;
     username;
@@ -28,9 +23,9 @@ class TextFileMessageStorage {
         if (!this.isEnabled) {
             return;
         }
-        const logPath = path_1.default.join(config_1.default.getUserLogsPath(), this.username, TextFileMessageStorage.getNetworkFolderName(network));
+        const logPath = path.join(Config.getUserLogsPath(), this.username, TextFileMessageStorage.getNetworkFolderName(network));
         try {
-            await promises_1.default.mkdir(logPath, { recursive: true });
+            await fs.mkdir(logPath, { recursive: true });
         }
         catch (e) {
             throw new Error(`Unable to create logs directory: ${e}`);
@@ -38,47 +33,47 @@ class TextFileMessageStorage {
         let line = `[${msg.time.toISOString()}] `;
         // message types from src/models/msg.js
         switch (msg.type) {
-            case msg_1.MessageType.ACTION:
+            case MessageType.ACTION:
                 // [2014-01-01 00:00:00] * @Arnold is eating cookies
                 line += `* ${msg.from.mode}${msg.from.nick} ${msg.text}`;
                 break;
-            case msg_1.MessageType.JOIN:
+            case MessageType.JOIN:
                 // [2014-01-01 00:00:00] *** Arnold (~arnold@foo.bar) joined
                 line += `*** ${msg.from.nick} (${msg.hostmask}) joined`;
                 break;
-            case msg_1.MessageType.KICK:
+            case MessageType.KICK:
                 // [2014-01-01 00:00:00] *** Arnold was kicked by Bernie (Don't steal my cookies!)
                 line += `*** ${msg.target.nick} was kicked by ${msg.from.nick} (${msg.text})`;
                 break;
-            case msg_1.MessageType.MESSAGE:
+            case MessageType.MESSAGE:
                 // [2014-01-01 00:00:00] <@Arnold> Put that cookie down.. Now!!
                 line += `<${msg.from.mode}${msg.from.nick}> ${msg.text}`;
                 break;
-            case msg_1.MessageType.MODE:
+            case MessageType.MODE:
                 // [2014-01-01 00:00:00] *** Arnold set mode +o Bernie
                 line += `*** ${msg.from.nick} set mode ${msg.text}`;
                 break;
-            case msg_1.MessageType.NICK:
+            case MessageType.NICK:
                 // [2014-01-01 00:00:00] *** Arnold changed nick to Bernie
                 line += `*** ${msg.from.nick} changed nick to ${msg.new_nick}`;
                 break;
-            case msg_1.MessageType.NOTICE:
+            case MessageType.NOTICE:
                 // [2014-01-01 00:00:00] -Arnold- pssst, I have cookies!
                 line += `-${msg.from.nick}- ${msg.text}`;
                 break;
-            case msg_1.MessageType.PART:
+            case MessageType.PART:
                 // [2014-01-01 00:00:00] *** Arnold (~arnold@foo.bar) left (Bye all!)
                 line += `*** ${msg.from.nick} (${msg.hostmask}) left (${msg.text})`;
                 break;
-            case msg_1.MessageType.QUIT:
+            case MessageType.QUIT:
                 // [2014-01-01 00:00:00] *** Arnold (~arnold@foo.bar) quit (Connection reset by peer)
                 line += `*** ${msg.from.nick} (${msg.hostmask}) quit (${msg.text})`;
                 break;
-            case msg_1.MessageType.CHGHOST:
+            case MessageType.CHGHOST:
                 // [2014-01-01 00:00:00] *** Arnold changed host to: new@fancy.host
                 line += `*** ${msg.from.nick} changed host to '${msg.new_ident}@${msg.new_host}'`;
                 break;
-            case msg_1.MessageType.TOPIC:
+            case MessageType.TOPIC:
                 // [2014-01-01 00:00:00] *** Arnold changed topic to: welcome everyone!
                 line += `*** ${msg.from.nick} changed topic to '${msg.text}'`;
                 break;
@@ -88,7 +83,7 @@ class TextFileMessageStorage {
         }
         line += "\n";
         try {
-            await promises_1.default.appendFile(path_1.default.join(logPath, TextFileMessageStorage.getChannelFileName(channel)), line);
+            await fs.appendFile(path.join(logPath, TextFileMessageStorage.getChannelFileName(channel)), line);
         }
         catch (e) {
             throw new Error(`Failed to write user log: ${e}`);
@@ -116,9 +111,9 @@ class TextFileMessageStorage {
         return `${cleanFilename(channel.name)}.log`;
     }
 }
-exports.default = TextFileMessageStorage;
+export default TextFileMessageStorage;
 function cleanFilename(name) {
-    name = (0, filenamify_1.default)(name, { replacement: "_" });
+    name = filenamify(name, { replacement: "_" });
     name = name.toLowerCase();
     return name;
 }

package/dist/server/plugins/packages/index.js

@@ -1,19 +1,15 @@
-"use strict";
-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 log_1 = __importDefault(require("../../log"));
-const chalk_1 = __importDefault(require("chalk"));
-const path_1 = __importDefault(require("path"));
-const semver_1 = __importDefault(require("semver"));
-const helper_1 = __importDefault(require("../../helper"));
-const config_1 = __importDefault(require("../../config"));
-const themes_1 = __importDefault(require("./themes"));
-const inputs_1 = __importDefault(require("../inputs"));
-const fs_1 = __importDefault(require("fs"));
-const utils_1 = __importDefault(require("../../command-line/utils"));
+import _ from "lodash";
+import log from "../../log.js";
+import colors from "chalk";
+import path from "path";
+import semver from "semver";
+import Helper from "../../helper.js";
+import Config from "../../config.js";
+import themes from "./themes.js";
+import inputs from "../inputs/index.js";
+import fs from "fs";
+import Utils from "../../command-line/utils.js";
+import { pathToFileURL } from "url";
 const packageMap = new Map();
 const stylesheets = [];
 const files = [];
@@ -22,12 +18,15 @@ const cache = {
     outdated: undefined,
 };
 let experimentalWarningPrinted = false;
-exports.default = {
+let packageWatcher = null;
+export default {
     getFiles,
     getStylesheets,
     getPackage,
     loadPackages,
     outdated,
+    stopWatching,
+    clearPackages,
 };
 // TODO: verify binds worked. Used to be 'this' instead of 'packageApis'
 const packageApis = function (packageInfo) {
@@ -39,18 +38,18 @@ const packageApis = function (packageInfo) {
             add: addFile.bind(packageApis, packageInfo.packageName),
         },
         Commands: {
-            add: inputs_1.default.addPluginCommand.bind(packageApis, packageInfo),
+            add: inputs.addPluginCommand.bind(packageApis, packageInfo),
             runAsUser: (command, targetId, client) => client.inputLine({ target: targetId, text: command }),
         },
         Config: {
-            getConfig: () => config_1.default.values,
+            getConfig: () => Config.values,
             getPersistentStorageDir: getPersistentStorageDir.bind(packageApis, packageInfo.packageName),
         },
         Logger: {
-            error: (...args) => log_1.default.error(`[${packageInfo.packageName}]`, ...args),
-            warn: (...args) => log_1.default.warn(`[${packageInfo.packageName}]`, ...args),
-            info: (...args) => log_1.default.info(`[${packageInfo.packageName}]`, ...args),
-            debug: (...args) => log_1.default.debug(`[${packageInfo.packageName}]`, ...args),
+            error: (...args) => log.error(`[${packageInfo.packageName}]`, ...args),
+            warn: (...args) => log.warn(`[${packageInfo.packageName}]`, ...args),
+            info: (...args) => log.info(`[${packageInfo.packageName}]`, ...args),
+            debug: (...args) => log.debug(`[${packageInfo.packageName}]`, ...args),
         },
     };
 };
@@ -69,43 +68,82 @@ function getFiles() {
 function getPackage(name) {
     return packageMap.get(name);
 }
+function clearPackages() {
+    packageMap.clear();
+    stylesheets.length = 0;
+    files.length = 0;
+    experimentalWarningPrinted = false;
+}
 function getEnabledPackages(packageJson) {
     try {
-        const json = JSON.parse(fs_1.default.readFileSync(packageJson, "utf-8"));
+        const json = JSON.parse(fs.readFileSync(packageJson, "utf-8"));
         return Object.keys(json.dependencies);
     }
     catch (e) {
-        log_1.default.error(`Failed to read packages/package.json: ${chalk_1.default.red(e)}`);
+        log.error(`Failed to read packages/package.json: ${colors.red(e)}`);
     }
     return [];
 }
 function getPersistentStorageDir(packageName) {
-    const dir = path_1.default.join(config_1.default.getPackagesPath(), packageName);
-    fs_1.default.mkdirSync(dir, { recursive: true }); // we don't care if it already exists or not
+    const dir = path.join(Config.getPackagesPath(), packageName);
+    fs.mkdirSync(dir, { recursive: true }); // we don't care if it already exists or not
     return dir;
 }
-function loadPackage(packageName) {
+async function loadPackage(packageName) {
     let packageInfo;
     // TODO: type
     let packageFile;
     try {
-        const packagePath = config_1.default.getPackageModulePath(packageName);
-        packageInfo = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packagePath, "package.json"), "utf-8"));
+        const packagePath = Config.getPackageModulePath(packageName);
+        packageInfo = JSON.parse(fs.readFileSync(path.join(packagePath, "package.json"), "utf-8"));
         if (!packageInfo.thelounge) {
-            throw "'thelounge' is not present in package.json";
+            throw new Error("'thelounge' is not present in package.json");
         }
         if (packageInfo.thelounge.supports &&
-            !semver_1.default.satisfies(helper_1.default.getVersionNumber(), packageInfo.thelounge.supports, {
+            !semver.satisfies(Helper.getVersionNumber(), packageInfo.thelounge.supports, {
                 includePrerelease: true, // our pre-releases should respect the semver guarantees
             })) {
-            throw `v${packageInfo.version} does not support this version of The Lounge. Supports: ${packageInfo.thelounge.supports}`;
+            throw new Error(`v${packageInfo.version} does not support this version of The Lounge. Supports: ${packageInfo.thelounge.supports}`);
+        }
+        // ESM requires importing a file, not a directory
+        // Determine the entry point from package.json
+        let entryPoint = "index.js";
+        if (typeof packageInfo.exports === "string") {
+            entryPoint = packageInfo.exports;
+        }
+        else if (packageInfo.exports && typeof packageInfo.exports === "object") {
+            // Handle exports map like { ".": "./index.js" } or { "import": "...", "require": "..." }
+            const exportsObj = packageInfo.exports;
+            if (typeof exportsObj["."] === "string") {
+                entryPoint = exportsObj["."];
+            }
+            else if (typeof exportsObj.import === "string") {
+                entryPoint = exportsObj.import;
+            }
+            else if (typeof exportsObj.require === "string") {
+                entryPoint = exportsObj.require;
+            }
+            else if (exportsObj["."] && typeof exportsObj["."] === "object") {
+                const dotExports = exportsObj["."];
+                entryPoint =
+                    dotExports.import || dotExports.require || dotExports.default || "index.js";
+            }
+        }
+        else if (packageInfo.main) {
+            entryPoint = packageInfo.main;
         }
-        packageFile = require(packagePath);
+        const isJSONImport = entryPoint.endsWith(".json");
+        const fullEntryPath = pathToFileURL(path.join(packagePath, entryPoint)).href;
+        const imported = isJSONImport
+            ? await import(fullEntryPath, { with: { type: "json" } })
+            : await import(fullEntryPath);
+        // Handle both ESM (direct exports) and CommonJS (wrapped in .default) modules
+        packageFile = imported.default || imported;
     }
     catch (e) {
-        log_1.default.error(`Package ${chalk_1.default.bold(packageName)} could not be loaded: ${chalk_1.default.red(e)}`);
+        log.error(`Package ${colors.bold(packageName)} could not be loaded: ${colors.red(e)}`);
         if (e instanceof Error) {
-            log_1.default.debug(e.stack ? e.stack : e.message);
+            log.debug(e.stack ? e.stack : e.message);
         }
         return;
     }
@@ -117,8 +155,8 @@ function loadPackage(packageName) {
     };
     packageMap.set(packageName, packageFile);
     if (packageInfo.type === "theme") {
-        // @ts-expect-error Argument of type 'PackageInfo' is not assignable to parameter of type 'ThemeModule'.
-        themes_1.default.addTheme(packageName, packageInfo);
+        // PackageInfo includes theme-specific fields when type === "theme"
+        themes.addTheme(packageName, packageInfo);
         if (packageInfo.files) {
             packageInfo.files.forEach((file) => addFile(packageName, file));
         }
@@ -126,68 +164,61 @@ function loadPackage(packageName) {
     if (packageFile.onServerStart) {
         packageFile.onServerStart(packageApis(packageInfo));
     }
-    log_1.default.info(`Package ${chalk_1.default.bold(packageName)} ${chalk_1.default.green("v" + version)} loaded`);
+    log.info(`Package ${colors.bold(packageName)} ${colors.green("v" + version)} loaded`);
     if (packageInfo.type !== "theme" && !experimentalWarningPrinted) {
         experimentalWarningPrinted = true;
-        log_1.default.info("There are packages using the experimental plugin API. " +
+        log.info("There are packages using the experimental plugin API. " +
             "Be aware that this API is not yet stable and may change in future The Lounge releases.");
     }
 }
-function loadPackages() {
-    const packageJson = path_1.default.join(config_1.default.getPackagesPath(), "package.json");
+async function loadPackages() {
+    const packageJson = path.join(Config.getPackagesPath(), "package.json");
     const packages = getEnabledPackages(packageJson);
-    packages.forEach(loadPackage);
+    await Promise.all(packages.map((pkg) => loadPackage(pkg)));
     watchPackages(packageJson);
 }
 function watchPackages(packageJson) {
-    fs_1.default.watch(packageJson, {
+    packageWatcher = fs.watch(packageJson, {
         persistent: false,
-    }, lodash_1.default.debounce(() => {
-        const updated = getEnabledPackages(packageJson);
-        for (const packageName of updated) {
-            if (packageMap.has(packageName)) {
-                continue;
+    }, _.debounce(() => {
+        void (async () => {
+            const updated = getEnabledPackages(packageJson);
+            for (const packageName of updated) {
+                if (packageMap.has(packageName)) {
+                    continue;
+                }
+                await loadPackage(packageName);
             }
-            loadPackage(packageName);
-        }
+        })();
     }, 1000, { maxWait: 10000 }));
 }
+function stopWatching() {
+    if (packageWatcher) {
+        packageWatcher.close();
+        packageWatcher = null;
+    }
+}
 async function outdated(cacheTimeout = TIME_TO_LIVE) {
     if (cache.outdated !== undefined) {
         return cache.outdated;
     }
     // Get paths to the location of packages directory
-    const packagesPath = config_1.default.getPackagesPath();
-    const packagesConfig = path_1.default.join(packagesPath, "package.json");
-    const packagesList = JSON.parse(fs_1.default.readFileSync(packagesConfig, "utf-8")).dependencies;
-    const argsList = [
-        "outdated",
-        "--latest",
-        "--json",
-        "--production",
-        "--ignore-scripts",
-        "--non-interactive",
-        "--cwd",
-        packagesPath,
-    ];
+    const packagesPath = Config.getPackagesPath();
+    const packagesConfig = path.join(packagesPath, "package.json");
+    const packagesList = JSON.parse(fs.readFileSync(packagesConfig, "utf-8")).dependencies;
     // Check if the configuration file exists
     if (!Object.entries(packagesList).length) {
         // CLI calls outdated with zero TTL, so we can print the warning there
         if (!cacheTimeout) {
-            log_1.default.warn("There are no packages installed.");
+            log.warn("There are no packages installed.");
         }
         return false;
     }
-    const command = argsList.shift();
-    const params = argsList;
-    if (!command) {
-        return;
-    }
-    // If we get an error from calling outdated and the code isn't 0, then there are no outdated packages
-    // TODO: was (...argsList), verify this works
-    await utils_1.default.executeYarnCommand(command, ...params)
+    // npm outdated returns exit code 1 when packages are outdated, 0 when all up to date
+    // executeYarnCommand handles this mapping
+    await Utils.executeYarnCommand("outdated")
         .then(() => updateOutdated(false))
-        .catch((code) => updateOutdated(code !== 0));
+        .catch(() => updateOutdated(true));
     if (cacheTimeout > 0) {
         setTimeout(() => {
             delete cache.outdated;

package/dist/server/plugins/packages/publicClient.js

@@ -1,11 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-class PublicClient {
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+export default class PublicClient {
     client;
     packageInfo;
     constructor(client, packageInfo) {
@@ -33,11 +28,8 @@ class PublicClient {
      * @param {String} event - Name of the event, must be something the browser will recognise
      * @param {Object} data - Body of the event, can be anything, but will need to be properly interpreted by the client
      */
-    // FIXME: this is utterly bonkers
-    // This needs to get wrapped into its own, typed plugin event
-    // Plus it is completely insane to let a plugin inject arbitrary events like that
-    sendToBrowser(event, data) {
-        this.client.emit(event, data);
+    sendToBrowser(event, ...args) {
+        this.client.emit(event, ...args);
     }
     /**
      *
@@ -53,8 +45,8 @@ class PublicClient {
      * @param {Chan} chan the channel to send the message to
      */
     sendMessage(text, chan) {
-        chan.pushMessage(this.client, new msg_1.default({
-            type: msg_2.MessageType.PLUGIN,
+        chan.pushMessage(this.client, new Msg({
+            type: MessageType.PLUGIN,
             text: text,
             from: {
                 nick: this.packageInfo.name || this.packageInfo.packageName,
@@ -63,4 +55,3 @@ class PublicClient {
         }));
     }
 }
-exports.default = PublicClient;

package/dist/server/plugins/packages/themes.js

@@ -1,22 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const lodash_1 = __importDefault(require("lodash"));
-const config_1 = __importDefault(require("../../config"));
-const utils_1 = __importDefault(require("../../command-line/utils"));
+import fs from "fs";
+import path from "path";
+import _ from "lodash";
+import Config from "../../config.js";
+import Utils from "../../command-line/utils.js";
 const themes = new Map();
-exports.default = {
+export default {
     addTheme,
     getAll,
     getByName,
     loadLocalThemes,
 };
 function loadLocalThemes() {
-    const builtInThemes = fs_1.default.readdirSync(utils_1.default.getFileFromRelativeToRoot("public", "themes"));
+    const builtInThemes = fs.readdirSync(Utils.getFileFromRelativeToRoot("public", "themes"));
     builtInThemes
         .filter((theme) => theme.endsWith(".css"))
         .map(makeLocalThemeObject)
@@ -31,9 +26,9 @@ function addTheme(packageName, packageObject) {
 function getAll() {
     const filteredThemes = [];
     for (const theme of themes.values()) {
-        filteredThemes.push(lodash_1.default.pick(theme, ["displayName", "name", "themeColor"]));
+        filteredThemes.push(_.pick(theme, ["displayName", "name", "themeColor"]));
     }
-    return lodash_1.default.sortBy(filteredThemes, "displayName");
+    return _.sortBy(filteredThemes, "displayName");
 }
 function getByName(name) {
     return themes.get(name);
@@ -51,10 +46,10 @@ function makePackageThemeObject(moduleName, module) {
         return;
     }
     const themeColor = /^#[0-9A-F]{6}$/i.test(module.themeColor) ? module.themeColor : null;
-    const modulePath = config_1.default.getPackageModulePath(moduleName);
+    const modulePath = Config.getPackageModulePath(moduleName);
     return {
         displayName: module.name || moduleName,
-        filename: path_1.default.join(modulePath, module.css),
+        filename: path.join(modulePath, module.css),
         name: encodeURIComponent(moduleName),
         themeColor: themeColor,
     };

package/dist/server/plugins/storage.js

@@ -1,13 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const log_1 = __importDefault(require("../log"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const crypto_1 = __importDefault(require("crypto"));
-const config_1 = __importDefault(require("../config"));
+import log from "../log.js";
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import Config from "../config.js";
 class Storage {
     references;
     constructor() {
@@ -17,55 +12,55 @@ class Storage {
         // Ensures that a directory is empty.
         // Deletes directory contents if the directory is not empty.
         // If the directory does not exist, it is created.
-        const dir = config_1.default.getStoragePath();
+        const dir = Config.getStoragePath();
         let items;
         try {
-            items = fs_1.default.readdirSync(dir);
+            items = fs.readdirSync(dir);
         }
-        catch (e) {
-            fs_1.default.mkdirSync(dir, { recursive: true });
+        catch {
+            fs.mkdirSync(dir, { recursive: true });
             return;
         }
         // TODO: Use `fs.rmdirSync(dir, {recursive: true});` when it's stable (node 13+)
-        items.forEach((item) => deleteFolder(path_1.default.join(dir, item)));
+        items.forEach((item) => deleteFolder(path.join(dir, item)));
     }
     dereference(url) {
         const references = (this.references.get(url) || 0) - 1;
         if (references < 0) {
-            return log_1.default.warn("Tried to dereference a file that has no references", url);
+            return log.warn("Tried to dereference a file that has no references", url);
         }
         if (references > 0) {
             return this.references.set(url, references);
         }
         this.references.delete(url);
         // Drop "storage/" from url and join it with full storage path
-        const filePath = path_1.default.join(config_1.default.getStoragePath(), url.substring(8));
-        fs_1.default.unlink(filePath, (err) => {
+        const filePath = path.join(Config.getStoragePath(), url.substring(8));
+        fs.unlink(filePath, (err) => {
             if (err) {
-                log_1.default.error("Failed to delete stored file", err.message);
+                log.error("Failed to delete stored file", err.message);
             }
         });
     }
     store(data, extension, callback) {
-        const hash = crypto_1.default.createHash("sha256").update(data).digest("hex");
+        const hash = crypto.createHash("sha256").update(data).digest("hex");
         const a = hash.substring(0, 2);
         const b = hash.substring(2, 4);
-        const folder = path_1.default.join(config_1.default.getStoragePath(), a, b);
-        const filePath = path_1.default.join(folder, `${hash.substring(4)}.${extension}`);
+        const folder = path.join(Config.getStoragePath(), a, b);
+        const filePath = path.join(folder, `${hash.substring(4)}.${extension}`);
         const url = `storage/${a}/${b}/${hash.substring(4)}.${extension}`;
         this.references.set(url, 1 + (this.references.get(url) || 0));
         // If file with this name already exists, we don't need to write it again
-        if (fs_1.default.existsSync(filePath)) {
+        if (fs.existsSync(filePath)) {
             return callback(url);
         }
-        fs_1.default.mkdir(folder, { recursive: true }, (mkdirErr) => {
+        fs.mkdir(folder, { recursive: true }, (mkdirErr) => {
             if (mkdirErr) {
-                log_1.default.error("Failed to create storage folder", mkdirErr.message);
+                log.error("Failed to create storage folder", mkdirErr.message);
                 return callback("");
             }
-            fs_1.default.writeFile(filePath, data, (err) => {
+            fs.writeFile(filePath, data, (err) => {
                 if (err) {
-                    log_1.default.error("Failed to store a file", err.message);
+                    log.error("Failed to store a file", err.message);
                     return callback("");
                 }
                 callback(url);
@@ -73,16 +68,16 @@ class Storage {
         });
     }
 }
-exports.default = new Storage();
+export default new Storage();
 function deleteFolder(dir) {
-    fs_1.default.readdirSync(dir).forEach((item) => {
-        item = path_1.default.join(dir, item);
-        if (fs_1.default.lstatSync(item).isDirectory()) {
+    fs.readdirSync(dir).forEach((item) => {
+        item = path.join(dir, item);
+        if (fs.lstatSync(item).isDirectory()) {
             deleteFolder(item);
         }
         else {
-            fs_1.default.unlinkSync(item);
+            fs.unlinkSync(item);
         }
     });
-    fs_1.default.rmdirSync(dir);
+    fs.rmdirSync(dir);
 }