@open-discord-bots/framework 0.0.1 → 0.0.2

package/src/index.ts

@@ -1 +1,6 @@
-import * as discord from "discord.js"
+export * as api from "./api/api"
+export * as utilities from "./api/utils"
+export * as cli from "./cli/cli"
+export { loadDumpCommand } from "./startup/dump"
+export { loadAllPlugins } from "./startup/pluginLauncher"
+export { frameworkStartup } from "./startup/compilation"

package/src/startup/compilation.ts

@@ -0,0 +1,186 @@
+import fs from "fs"
+import ts from "typescript"
+import { createHash, Hash } from "crypto"
+import nodepath from "path"
+import ansis from "ansis"
+import type { ODProjectType } from "../api/api"
+
+/** ## What is this?
+ * This is a function which compares `./src/` with a hash stored in `./dist/hash.txt`.
+ * The hash is based on the modified date & file metadata of all files in `./src/`.
+ * 
+ * If the hash is different, the bot will automatically re-compile.
+ * This will help you save CPU resources because the bot shouldn't re-compile when nothing has been changed :)
+ */
+function computeSourceHash(dir:string,upperHash?:Hash){
+    const hash = upperHash ? upperHash : createHash("sha256")
+    const info = fs.readdirSync(dir,{withFileTypes:true})
+    
+    for (const file of info) {
+        const fullPath = nodepath.join(dir,file.name)
+        if (file.isFile() && [".js",".ts",".jsx",".tsx"].some((ext) => file.name.endsWith(ext))){
+            const statInfo = fs.statSync(fullPath)
+            //compute hash using file metadata
+            const fileInfo = `${fullPath}:${statInfo.size}:${statInfo.mtimeMs}`
+            hash.update(fileInfo)
+            
+        }else if (file.isDirectory()){
+            //recursively compute all folders
+            computeSourceHash(fullPath,hash)
+        }
+    }
+    //return when not being called recursively
+    if (!upperHash){
+        return hash.digest("hex")
+    }
+}
+
+function requiresCompilation(project:ODProjectType){
+    const logTitle = (project == "openticket") ? "OT" : "OM"
+
+    //check hashes when not using "--compile-only" flag
+    if (process.argv.includes("--compile-only")) return true
+
+    console.log(logTitle+": Comparing prebuilds with source...")
+    const sourceHash = computeSourceHash("./src/")
+    const pluginHash = computeSourceHash("./plugins/")
+    const hash = sourceHash+":"+pluginHash
+
+    if (fs.existsSync("./dist/hash.txt")){
+        const distHash = fs.readFileSync("./dist/hash.txt").toString()
+        if (distHash === hash) return false
+        else return true
+    }else return true
+}
+
+function saveNewCompilationHash(){
+    const sourceHash = computeSourceHash("./src/")
+    const pluginHash = computeSourceHash("./plugins/")
+    const hash = sourceHash+":"+pluginHash
+    fs.writeFileSync("./dist/hash.txt",hash)
+}
+
+export function frameworkStartup(startupFlags:string[],project:ODProjectType,startCallback:() => void){
+    const logTitle = (project == "openticket") ? "OT" : "OM"
+
+    //push additional startup flags (for pterodactyl panels)
+    process.argv.push(...startupFlags)
+
+    //check directory structure
+    const requiredStructures: string[] = [
+        "index.js",
+        "./package.json",
+        "./README.md",
+        "./LICENSE.md",
+        "./tsconfig.json",
+        "./src/",
+        "./src/index.ts",
+        "./languages/",
+        "./config/",
+        "./plugins/",
+        "./.github/",
+        "./.github/FUNDING.yml",
+        "./.github/SECURITY.yml"
+    ]
+    for (const path of requiredStructures){
+        if (!fs.existsSync(path)) throw new Error(logTitle+": Project uses invalid structure for Open Discord! ("+path+")")
+    }
+
+    //start compilation
+    if (!process.argv.includes("--no-compile")){
+        const requiredDependencies: Set<string> = new Set()
+        if (fs.existsSync("./plugins")){
+            console.log(logTitle+": Reading plugin.json files...")
+            for (const pluginDir of fs.readdirSync("./plugins")){
+                if (pluginDir === ".DS_Store") continue
+                const pluginPath = nodepath.join("./plugins", pluginDir)
+                if (!fs.statSync(pluginPath).isDirectory()) continue
+                
+                const pluginJsonPath = nodepath.join(pluginPath, "plugin.json")
+                if (fs.existsSync(pluginJsonPath)){
+                    try{
+                        const pluginData = JSON.parse(fs.readFileSync(pluginJsonPath).toString())
+                        if (pluginData.npmDependencies && Array.isArray(pluginData.npmDependencies)){
+                            pluginData.npmDependencies.forEach((dep) => {
+                                if (typeof dep === "string" && dep.trim()){
+                                    requiredDependencies.add(dep.trim())
+                                }
+                            })
+                        }
+                    }catch(err){
+                        // skip invalid plugin.json files, will be caught later
+                    }
+                }
+            }
+            
+            if (requiredDependencies.size > 0){
+                console.log(logTitle+": Checking plugin npm dependencies...")
+                const missingDeps: string[] = []
+                for (const dep of requiredDependencies){
+                    try{
+                        require.resolve(dep)
+                    }catch(err){
+                        missingDeps.push(dep)
+                    }
+                }
+                
+                if (missingDeps.length > 0){
+                    console.log(ansis.red(logTitle+": ❌ Fatal Error --> Missing npm dependencies required by plugins:\n\n")+ansis.cyan(missingDeps.map((dep) => "  - "+dep).join("\n")+"\n"))
+                    console.log(logTitle+": Please install missing dependencies using the following command:\n> "+ansis.bold.green("npm install " + missingDeps.join(" "))+"\n")
+                    process.exit(1)
+                }
+            }
+        }
+        
+        if (requiresCompilation(project)){
+            console.log(logTitle+": Compilation Required...")
+
+            //REMOVE EXISTING BUILDS
+            console.log(logTitle+": Removing Prebuilds...")
+            fs.rmSync("./dist",{recursive:true,force:true})
+
+            //COMPILE TYPESCRIPT
+            console.log(logTitle+": Compiling Typescript...")
+            const configPath = nodepath.resolve('./tsconfig.json')
+            const configFile = ts.readConfigFile(configPath,ts.sys.readFile)
+
+            //check for tsconfig errors
+            if (configFile.error){
+                const message = ts.formatDiagnosticsWithColorAndContext([configFile.error],ts.createCompilerHost({}))
+                console.error(message)
+                process.exit(1)
+            }
+
+            //parse tsconfig file
+            const parsedConfig = ts.parseJsonConfigFileContent(configFile.config,ts.sys,nodepath.dirname(configPath))
+
+            //create program/compiler
+            const program = ts.createProgram({
+                rootNames:parsedConfig.fileNames,
+                options:parsedConfig.options
+            })
+
+            //emit all compiled files
+            const emitResult = program.emit()
+
+            //print emit errors/warnings (type errors)
+            const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
+            const formattedDiagnostics = ts.formatDiagnosticsWithColorAndContext(allDiagnostics, ts.createCompilerHost(parsedConfig.options))
+            console.log(formattedDiagnostics)
+
+            if (emitResult.emitSkipped || allDiagnostics.find((d) => d.category == ts.DiagnosticCategory.Error || d.category == ts.DiagnosticCategory.Warning)){
+                console.log(logTitle+": Compilation Failed!")
+                process.exit(1)
+            }
+        }else console.log(logTitle+": No Compilation Required...")
+
+        //save new compilation hash
+        saveNewCompilationHash()
+    }
+
+    //START BOT
+    console.log(logTitle+": Compilation Succeeded!")
+    if (process.argv.includes("--compile-only")) process.exit(0) //exit when no startup is required!
+    console.log(logTitle+": Starting Bot!")
+    startCallback()
+}

package/src/startup/dump.ts

@@ -0,0 +1,45 @@
+import {api, utilities} from "../index"
+import * as discord from "discord.js"
+import * as fs from "fs"
+
+
+/** ### What is this?
+ * This is the `!OPENTICKET:dump` command.
+ * It's a utility command which can only be used by the creator of Open Discord/Ticket/Moderation or the owner of the bot.
+ * This command will send the `debug.txt` file in DM. It's not dangerous as the `debug.txt` file doesn't contain any sensitive data (only logs).
+ * 
+ * ### Why does it exist?
+ * This command can be used to quickly get the `debug.txt` file without having access to the hosting
+ * in case you're helping someone with setting up (or debugging) Open Discord/Ticket/Moderation.
+ * 
+ * ### Can I disable it?
+ * If you want to turn it off, you turn off the fuse using `opendiscord.sharedFuses.setFuse("allowDumpCommand",false)`
+ */
+
+export const loadDumpCommand = (opendiscord:api.ODMain) => {
+    if (!opendiscord.sharedFuses.getFuse("allowDumpCommand")) return
+    opendiscord.client.textCommands.add(new api.ODTextCommand("opendiscord:dump",{
+        allowBots:false,
+        guildPermission:true,
+        dmPermission:true,
+        name:"dump",
+        prefix:"!OPENTICKET:"
+    }))
+
+    opendiscord.client.textCommands.onInteraction("!OPENTICKET:","dump",async (msg) => {
+        if (msg.author.id == "779742674932072469" || opendiscord.permissions.hasPermissions("developer",await opendiscord.permissions.getPermissions(msg.author,msg.channel,null))){
+            //user is bot owner OR creator of Open Discord/Ticket/Moderation :)
+            opendiscord.log("Dumped "+opendiscord.debugfile.filename+"!","system",[
+                {key:"user",value:msg.author.username},
+                {key:"id",value:msg.author.id}
+            ])
+            const debug = fs.readFileSync(opendiscord.debugfile.path)
+
+            if (msg.channel.type != discord.ChannelType.GroupDM) msg.channel.send({content:"## The `"+opendiscord.debugfile.filename+"` dump is available!",files:[
+                new discord.AttachmentBuilder(debug)
+                    .setName(opendiscord.debugfile.filename)
+                    .setDescription("The Open Discord debug dump!")
+            ]})
+        }
+    })
+}

package/src/startup/errorHandling.ts

@@ -0,0 +1,38 @@
+import {api, utilities} from "../index"
+
+export function loadErrorHandling(opendiscord:api.ODMain,project:api.ODProjectType){
+    process.on("uncaughtException",async (error,origin) => {
+        try{
+            const beforeEvent = opendiscord.events.get("onErrorHandling")
+            if (beforeEvent) await beforeEvent.emit([error,origin])
+
+            if (opendiscord.sharedFuses.getFuse("errorHandling")){
+                //custom error messages for known errors
+                if (error.message.toLowerCase().includes("used disallowed intents")){
+                    //invalid intents
+                    opendiscord.log(((project === "openticket") ? "Open Ticket" : "Open Moderation")+" doesn't work without Privileged Gateway Intents enabled!","error")
+                    opendiscord.log("Enable them in the discord developer portal!","info")
+                    console.log("\n")
+                    process.exit(1)
+                }else if (error.message.toLowerCase().includes("invalid discord bot token provided")){
+                    //invalid token
+                    opendiscord.log("An invalid discord auth token was provided!","error")
+                    opendiscord.log("Check the config if you have inserted the bot token correctly!","info")
+                    console.log("\n")
+                    process.exit(1)
+                }else{
+                    //unknown error
+                    const errmsg = new api.ODError(error,origin)
+                    opendiscord.log(errmsg)
+                    if (opendiscord.sharedFuses.getFuse("crashOnError")) process.exit(1)
+                    
+                    const afterEvent = opendiscord.events.get("afterErrorHandling")
+                    if (afterEvent) await afterEvent.emit([error,origin,errmsg])
+                }
+            }
+            
+        }catch(err){
+            console.log("[ERROR HANDLER ERROR]:",err)
+        }
+    })
+}

package/src/startup/pluginLauncher.ts

@@ -0,0 +1,261 @@
+import {api, utilities} from "../index"
+import fs from "fs"
+
+export const loadAllPlugins = async (opendiscord:api.ODMain) => {
+    //start launching plugins
+    opendiscord.log("Loading plugins...","system")
+    let initPluginError: boolean = false
+
+    if (!fs.existsSync("./plugins")){
+        opendiscord.log("Couldn't find ./plugins directory, canceling all plugin execution!","error")
+        return
+    }
+    const plugins = fs.readdirSync("./plugins")
+    const pluginVersionRegex = /^(OT|OM)v(\d+)\.(\d+|x)\.(\d+|x)$/
+
+    //check & validate
+    for (const p of plugins){
+        //prechecks
+        if (p === ".DS_Store") return //ignore MacOS DS_Store file
+        if (!fs.statSync("./plugins/"+p).isDirectory()) return opendiscord.log("Plugin is not a directory, canceling plugin execution...","plugin",[
+            {key:"plugin",value:"./plugins/"+p}
+        ])
+        if (!fs.existsSync("./plugins/"+p+"/plugin.json")){
+            initPluginError = true
+            opendiscord.log("Plugin doesn't have a plugin.json, canceling plugin execution...","plugin",[
+                {key:"plugin",value:"./plugins/"+p}
+            ])
+            return
+        }
+
+        //plugin loading
+        try {
+            const rawplugindata: api.ODPluginData = JSON.parse(fs.readFileSync("./plugins/"+p+"/plugin.json").toString())
+
+            if (typeof rawplugindata != "object") throw new api.ODPluginError("Failed to load plugin.json")
+            if (typeof rawplugindata.id != "string") throw new api.ODPluginError("Failed to load plugin.json/id")
+            if (typeof rawplugindata.name != "string") throw new api.ODPluginError("Failed to load plugin.json/name")
+            if (typeof rawplugindata.version != "string") throw new api.ODPluginError("Failed to load plugin.json/version")
+            if (typeof rawplugindata.startFile != "string") throw new api.ODPluginError("Failed to load plugin.json/startFile")
+
+            //only check "supportedVersions" if it exists (should be array)
+            if (rawplugindata.supportedVersions){
+                if (!Array.isArray(rawplugindata.supportedVersions)) throw new api.ODPluginError("Failed to load plugin.json/supportedVersions (must be array)")
+                for (const version of rawplugindata.supportedVersions){
+                    if (typeof version !== "string"){
+                        throw new api.ODPluginError("Failed to load plugin.json/supportedVersions (all items must be strings)")
+                    }
+                    //only OT (Open Ticket) & OM (Open Moderation) are supported at the moment
+                    if (!pluginVersionRegex.test(version)){
+                        throw new api.ODPluginError(`Failed to load plugin.json/supportedVersions (invalid format: "${version}", expected format like "OTv4.0.x" or "OMv1.0.0")`)
+                    }
+                }
+            }
+            
+            if (typeof rawplugindata.enabled != "boolean") throw new api.ODPluginError("Failed to load plugin.json/enabled")
+            if (typeof rawplugindata.priority != "number") throw new api.ODPluginError("Failed to load plugin.json/priority")
+            if (!Array.isArray(rawplugindata.events)) throw new api.ODPluginError("Failed to load plugin.json/events")
+            
+            if (!Array.isArray(rawplugindata.npmDependencies)) throw new api.ODPluginError("Failed to load plugin.json/npmDependencies")
+            if (!Array.isArray(rawplugindata.requiredPlugins)) throw new api.ODPluginError("Failed to load plugin.json/requiredPlugins")
+            if (!Array.isArray(rawplugindata.incompatiblePlugins)) throw new api.ODPluginError("Failed to load plugin.json/incompatiblePlugins")
+            
+            if (typeof rawplugindata.details != "object") throw new api.ODPluginError("Failed to load plugin.json/details")
+            if (typeof rawplugindata.details.author != "string") throw new api.ODPluginError("Failed to load plugin.json/details/author")
+            
+            //only check "contributors" if it exists (should be array)
+            if (rawplugindata.details.contributors && !Array.isArray(rawplugindata.details.contributors)) throw new api.ODPluginError("Failed to load plugin.json/details/contributors (must be array)")
+            
+            if (typeof rawplugindata.details.shortDescription != "string") throw new api.ODPluginError("Failed to load plugin.json/details/shortDescription")
+            if (typeof rawplugindata.details.longDescription != "string") throw new api.ODPluginError("Failed to load plugin.json/details/longDescription")
+            if (typeof rawplugindata.details.imageUrl != "string") throw new api.ODPluginError("Failed to load plugin.json/details/imageUrl")
+            if (typeof rawplugindata.details.projectUrl != "string") throw new api.ODPluginError("Failed to load plugin.json/details/projectUrl")
+            if (!Array.isArray(rawplugindata.details.tags)) throw new api.ODPluginError("Failed to load plugin.json/details/tags")
+            
+            if (rawplugindata.id != p) throw new api.ODPluginError("Failed to load plugin, directory name is required to match the id")
+            
+            if (opendiscord.plugins.exists(rawplugindata.id)) throw new api.ODPluginError("Failed to load plugin, this id already exists in another plugin")
+
+            //plugin.json is valid => load plugin
+            const plugin = new api.ODPlugin(p,rawplugindata)
+            opendiscord.plugins.add(plugin)
+
+        }catch(e){
+            //when any of the above errors happen, crash the bot when soft mode isn't enabled
+            initPluginError = true
+            opendiscord.log(e.message+", canceling plugin execution...","plugin",[
+                {key:"path",value:"./plugins/"+p}
+            ])
+            opendiscord.log("You can see more about this error in the ./debug.txt file!","info")
+            opendiscord.debugfile.writeText(e.stack)
+            
+            //try to get some crashed plugin data
+            try{
+                const rawplugindata: api.ODPluginData = JSON.parse(fs.readFileSync("./plugins/"+p+"/plugin.json").toString())
+                opendiscord.plugins.unknownCrashedPlugins.push({
+                    name:rawplugindata.name ?? "./plugins/"+p,
+                    description:(rawplugindata.details && rawplugindata.details.shortDescription) ? rawplugindata.details.shortDescription : "This plugin crashed :(",
+                })
+            }catch{}
+        }
+    }
+
+    //sorted plugins (sorted on priority. All plugins are loaded & enabled)
+    const sortedPlugins = opendiscord.plugins.getAll().sort((a,b) => {
+        return (b.priority - a.priority)
+    })
+
+    //check for incompatible & missing plugins/dependencies
+    const incompatibilities: {from:string,to:string}[] = []
+    const missingDependencies: {id:string,missing:string}[] = []
+    const missingPlugins: {id:string,missing:string}[] = []
+    const versionIncompatibilities: {id:string}[] = []
+
+    //go through all plugins for errors
+    sortedPlugins.filter((plugin) => plugin.enabled).forEach((plugin) => {
+        const from = plugin.id.value
+        plugin.dependenciesInstalled().forEach((missing) => missingDependencies.push({id:from,missing}))
+        plugin.pluginsIncompatible(opendiscord.plugins).forEach((incompatible) => incompatibilities.push({from,to:incompatible}))
+        plugin.pluginsInstalled(opendiscord.plugins).forEach((missing) => missingPlugins.push({id:from,missing}))
+
+        //check if plugins are compatible with version of bot
+        if (plugin.data.supportedVersions && plugin.data.supportedVersions.length > 0){
+            const currentVersion = opendiscord.versions.get("opendiscord:version")
+            if (!currentVersion) throw new api.ODSystemError("Unable to get project version: opendiscord.versions.get('opendiscord:version')!")
+            let isCompatible = false
+            
+            for (const versionStr of plugin.data.supportedVersions){
+                const match = versionStr.match(pluginVersionRegex)
+                if (!match) continue
+                
+                const projectPrefix = match[1]
+                const primary = parseInt(match[2])
+                const secondary = (match[3] === "x") ? null : parseInt(match[3])
+                const tertiary = (match[4] === "x") ? null : parseInt(match[4])
+                
+                if (projectPrefix !== "OT") continue
+                else if (primary !== currentVersion.primary) continue
+                else if (typeof secondary === "number" && secondary !== currentVersion.secondary) continue
+                else if (typeof tertiary === "number" && tertiary !== currentVersion.tertiary) continue
+                else{
+                    isCompatible = true
+                    break
+                }
+            }
+            
+            if (!isCompatible) versionIncompatibilities.push({id:from})
+        }
+    })
+
+    //handle all incompatibilities
+    const alreadyLoggedCompatPlugins: string[] = []
+    incompatibilities.forEach((match) => {
+        if (alreadyLoggedCompatPlugins.includes(match.from) || alreadyLoggedCompatPlugins.includes(match.to)) return
+        else alreadyLoggedCompatPlugins.push(match.from,match.to)
+
+        const fromPlugin = opendiscord.plugins.get(match.from)
+        if (fromPlugin && !fromPlugin.crashed){
+            fromPlugin.crashed = true
+            fromPlugin.crashReason = "incompatible.plugin"
+        }
+        const toPlugin = opendiscord.plugins.get(match.to)
+        if (toPlugin && !toPlugin.crashed){
+            toPlugin.crashed = true
+            toPlugin.crashReason = "incompatible.plugin"
+        }
+
+        opendiscord.log(`Incompatible plugins => "${match.from}" & "${match.to}", canceling plugin execution...`,"plugin",[
+            {key:"path1",value:"./plugins/"+match.from},
+            {key:"path2",value:"./plugins/"+match.to}
+        ])
+        initPluginError = true
+    })
+
+    //handle all missing dependencies
+    missingDependencies.forEach((match) => {
+        const plugin = opendiscord.plugins.get(match.id)
+        if (plugin && !plugin.crashed){
+            plugin.crashed = true
+            plugin.crashReason = "missing.dependency"
+        }
+
+        opendiscord.log(`Missing npm dependency "${match.missing}", canceling plugin execution...`,"plugin",[
+            {key:"path",value:"./plugins/"+match.id}
+        ])
+        initPluginError = true
+    })
+
+    //handle all missing plugins
+    missingPlugins.forEach((match) => {
+        const plugin = opendiscord.plugins.get(match.id)
+        if (plugin && !plugin.crashed){
+            plugin.crashed = true
+            plugin.crashReason = "missing.plugin"
+        }
+
+        opendiscord.log(`Missing required plugin "${match.missing}", canceling plugin execution...`,"plugin",[
+            {key:"path",value:"./plugins/"+match.id}
+        ])
+        initPluginError = true
+    })
+
+    //handle all bot version incompatibilities
+    versionIncompatibilities.forEach((match) => {
+        const plugin = opendiscord.plugins.get(match.id)
+        if (plugin && !plugin.crashed){
+            plugin.crashed = true
+            plugin.crashReason = "incompatible.version"
+        }
+
+        const versions = plugin?.data.supportedVersions?.join(", ") ?? "<unknown-version>"
+        const currentVersion = opendiscord.versions.get("opendiscord:version")?.toString() ?? "<OD:UNKNOWN_VERION>"
+        opendiscord.log(`Plugin version incompatibility: plugin requires "${versions}" but current bot version is "${currentVersion}", canceling plugin execution...`,"plugin",[
+            {key:"path",value:"./plugins/"+match.id}
+        ])
+        initPluginError = true
+    })
+
+    //exit on error (when soft mode disabled)
+    if (!opendiscord.sharedFuses.getFuse("softPluginLoading") && initPluginError){
+        console.log("")
+        opendiscord.log("Please fix all plugin errors above & try again!","error")
+        process.exit(1)
+    }
+
+    //preload all events required for every plugin
+    for (const plugin of sortedPlugins){
+        if (plugin.enabled) plugin.data.events.forEach((event) => opendiscord.events.add(new api.ODEvent(event)))
+    }
+    
+    //execute all working plugins
+    for (const plugin of sortedPlugins){
+        const status = await plugin.execute(opendiscord.debug,false)
+        
+        //exit on error (when soft mode disabled)
+        if (!status && !opendiscord.sharedFuses.getFuse("softPluginLoading")){
+            console.log("")
+            opendiscord.log("Please fix all plugin errors above & try again!","error")
+            process.exit(1)
+        }
+    }
+
+    for (const plugin of sortedPlugins){
+        const authors = [plugin.details.author,...(plugin.details.contributors ?? [])].join(", ")
+        
+        if (plugin.enabled){
+            opendiscord.debug.debug("Plugin \""+plugin.id.value+"\" loaded",[
+                {key:"status",value:(plugin.crashed ? "crashed" : "success")},
+                {key:"crashReason",value:(plugin.crashed ? (plugin.crashReason ?? "/") : "/")},
+                {key:"authors",value:authors},
+                {key:"version",value:plugin.version.toString()},
+                {key:"priority",value:plugin.priority.toString()}
+            ])
+        }else{
+            opendiscord.debug.debug("Plugin \""+plugin.id.value+"\" disabled",[
+                {key:"authors",value:authors},
+                {key:"version",value:plugin.version.toString()},
+                {key:"priority",value:plugin.priority.toString()}
+            ])
+        }
+    }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 DJj123dj
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.