Corrected libary > library typo

ElPumpo · ElPumpo · commit 2964f38c6eb1 · 2025-05-23T21:28:30.000+02:00
diff --git a/TinyNvidiaUpdateChecker/Handlers/LibraryHandler.cs b/TinyNvidiaUpdateChecker/Handlers/LibraryHandler.cs
@@ -5,78 +5,79 @@
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
-using static TinyNvidiaUpdateChecker.Handlers.LibaryHandler;
+using static TinyNvidiaUpdateChecker.Handlers.LibraryHandler;
 
 namespace TinyNvidiaUpdateChecker.Handlers
 {
 
-    class LibaryHandler
+    class LibraryHandler
     {
         private static bool is64 = Environment.Is64BitOperatingSystem;
 
-        static List<LibaryRegistryPath> libaryRegistryList =
+        static List<LibraryRegistryPath> libraryRegistryList 
+        =
             [
                 /* WinRAR */
 
-                new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Libary.WINRAR),
-                new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Libary.WINRAR),
+                new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Library.WINRAR),
+                new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Library.WINRAR),
 
                 /* 7-Zip */
 
                 // amd64 installer on amd64 system, or x86 on x86 system
-                new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Libary.SEVENZIP),
+                new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Library.SEVENZIP),
 
                 // x86 intaller on amd64 system
-                new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Libary.SEVENZIP),
+                new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Library.SEVENZIP),
 
                 // MSI amd64 installer on amd64 system, or x86 on x86 system
-                new(Registry.LocalMachine, @"SOFTWARE\7-Zip", "Path", Libary.SEVENZIP),
+                new(Registry.LocalMachine, @"SOFTWARE\7-Zip", "Path", Library.SEVENZIP),
 
                 // MSI x86 intaller on amd64 system
-                new (Registry.LocalMachine, @"SOFTWARE\WOW6432Node\7-Zip", "Path", Libary.SEVENZIP),
+                new (Registry.LocalMachine, @"SOFTWARE\WOW6432Node\7-Zip", "Path", Library.SEVENZIP),
             ];
 
-        static List<LibaryPath> libaryPathList =
+        static List<LibraryPath> LibraryPathList =
             [
                 /* 7-Zip */
 
                 // scoop in user profile
-                new([Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "scoop", "apps", "7zip", "current"], Libary.SEVENZIP),
+                new([Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "scoop", "apps", "7zip", "current"], Library.SEVENZIP),
 
                 // scoop in Program Data
-                new([Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "scoop", "apps", "7zip", "current"], Libary.SEVENZIP),
+                new([Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "scoop", "apps", "7zip", "current"], Library.SEVENZIP),
 
                 // scoop local environment variable
-                new([Environment.GetEnvironmentVariable("SCOOP", EnvironmentVariableTarget.User), "apps", "7zip", "current"], Libary.SEVENZIP),
+                new([Environment.GetEnvironmentVariable("SCOOP", EnvironmentVariableTarget.User), "apps", "7zip", "current"], Library.SEVENZIP),
 
                 // scoop global environment variable
-                new([Environment.GetEnvironmentVariable("SCOOP_GLOBAL", EnvironmentVariableTarget.Machine), "apps", "7zip", "current"], Libary.SEVENZIP),
+                new([Environment.GetEnvironmentVariable("SCOOP_GLOBAL", EnvironmentVariableTarget.Machine), "apps", "7zip", "current"], Library.SEVENZIP),
 
                 // amd64 on amd64 system, or x86 on x86 system
-                new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "7-Zip"], Libary.SEVENZIP),
+                new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "7-Zip"], Library.SEVENZIP),
 
                 // x86 on amd64 system
-                new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "7-Zip"], Libary.SEVENZIP),
+                new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "7-Zip"], Library.SEVENZIP),
                 
                 // custom path defined in config file
-                new([ConfigurationHandler.ReadSetting("Custom 7-ZIP Libary Path", null, false)], Libary.SEVENZIP),
+                new([ConfigurationHandler.ReadSetting("Custom 7-ZIP Library Path", null, false)], Library.SEVENZIP),
 
                 /* WinRAR */
-                new([ConfigurationHandler.ReadSetting("Custom WinRAR Libary Path", null, false)], Libary.WINRAR)
+                new([ConfigurationHandler.ReadSetting("Custom WinRAR Library Path", null, false)], Library.WINRAR)
             ];
 
-        static Dictionary<string, Libary> cliList = new() {
-            {"NanaZipC", Libary.NANAZIP} // NanaZip
+        static Dictionary<string, Library> cliList = new() {
+            {"NanaZipC", Library.NANAZIP} // NanaZip
         };
 
-        public enum Libary
+        public enum Library
         {
             SEVENZIP,
             WINRAR,
             NANAZIP
         }
 
-        public static LibaryFile EvaluateLibary()
+        public static LibraryFile EvaluateLibrary()
         {
             foreach (var entry in cliList)
             {
@@ -98,13 +99,14 @@ public static LibaryFile EvaluateLibary()
                     if (process.ExitCode == 0)
                     {
                         string directoryPath = Path.GetDirectoryName(exePath) + @"\";
-                        return new LibaryFile(directoryPath, entry.Value, true);
+                        return new LibraryFile(directoryPath, entry.Value, true);
                     }
                 }
                 catch { }
             }
 
-            foreach (var entry in libaryRegistryList)
+            foreach (var entry in libraryRegistryList)
+            
             {
                 try
                 {
@@ -128,23 +130,23 @@ public static LibaryFile EvaluateLibary()
                         path += @"\";
                     }
 
-                    string exe = LibaryPath.GetExeFromLibary(entry.libary);
+                    string exe = LibraryPath.GetExeFromLibrary(entry.library);
                     string exePath = Path.Combine(path, exe);
 
                     if (Path.Exists(exePath))
                     {
-                        return new LibaryFile(path, entry.libary, true);
+                        return new LibraryFile(path, entry.library, true);
                     }
                 }
                 catch { }
             }
 
-            foreach (var entry in libaryPathList)
+            foreach (var entry in LibraryPathList)
             {
                 if (entry.validate())
                 {
                     string path = Path.Combine(entry.path) + @"\";
-                    return new LibaryFile(path, entry.libary, true);
+                    return new LibraryFile(path, entry.library, true);
                 }
             }
 
@@ -167,22 +169,22 @@ public static string GetMainModuleFileName(this Process process, int buffer = 10
         }
     }
 
-    class LibaryPath
+    class LibraryPath
     {
         public string[] path;
-        public LibaryHandler.Libary libary;
+        public LibraryHandler.Library library;
 
-        public LibaryPath(string[] path, LibaryHandler.Libary libary)
+        public LibraryPath(string[] path, LibraryHandler.Library library)
         {
             this.path = path;
-            this.libary = libary;
+            this.library = library;
         }
 
         public bool validate()
         {
             try
             {
-                string exe = GetExeFromLibary(this.libary);
+                string exe = GetExeFromLibrary(this.library);
                 string path = Path.Combine([.. this.path, exe]);
 
                 if (Path.Exists(path))
@@ -195,30 +197,30 @@ public bool validate()
             return false;
         }
 
-        public static string GetExeFromLibary(Libary libary)
+        public static string GetExeFromLibrary(Library library)
         {
-            return libary switch
+            return library switch
             {
-                Libary.SEVENZIP => "7z.exe",
-                Libary.WINRAR => "winrar.exe",
+                Library.SEVENZIP => "7z.exe",
+                Library.WINRAR => "winrar.exe",
                 _ => "",
             };
         }
     }
 
-    class LibaryRegistryPath
+    class LibraryRegistryPath
     {
         public RegistryKey key;
         public string path;
         public string name;
-        public LibaryHandler.Libary libary;
+        public LibraryHandler.Library library;
 
-        public LibaryRegistryPath(RegistryKey key, string path, string name, LibaryHandler.Libary libary)
+        public LibraryRegistryPath(RegistryKey key, string path, string name, LibraryHandler.Library library)
         {
             this.key = key;
             this.path = path;
             this.name = name;
-            this.libary = libary;
+            this.library = library;
         }
 
         public RegistryHive getRegistryHive()
@@ -237,43 +239,43 @@ public RegistryHive getRegistryHive()
     /// <summary>
     /// Libaries that can extract the nvidia driver file
     /// </summary>
-    class LibaryFile
+    class LibraryFile
     {
         string installationDirectory;
-        LibaryHandler.Libary libary;
+        LibraryHandler.Library library;
         bool isInstalled;
 
-        public LibaryFile(string installationDirectory, LibaryHandler.Libary libary, bool isInstalled)
+        public LibraryFile(string installationDirectory, LibraryHandler.Library library, bool isInstalled)
         {
             this.installationDirectory = installationDirectory;
-            this.libary = libary;
+            this.library = library;
             this.isInstalled = isInstalled;
         }
 
-        public LibaryFile(LibaryHandler.Libary libary, bool isInstalled)
+        public LibraryFile(LibraryHandler.Library library, bool isInstalled)
         {
-            this.libary = libary;
+            this.library = library;
             this.isInstalled = isInstalled;
         }
 
         /// <summary>
-        /// Is the libary installed?
+        /// Is the library installed?
         /// </summary>
         public bool IsInstalled()
         {
             return isInstalled;
         }
 
         /// <summary>
-        /// Libary name
+        /// Library name
         /// </summary>
-        public LibaryHandler.Libary LibaryName()
+        public LibraryHandler.Library LibraryName()
         {
-            return libary;
+            return library;
         }
 
         /// <summary>
-        /// Get the absolute path to the libary, ending with a backslash
+        /// Get the absolute path to the library, ending with a backslash
         /// </summary>
         public string GetInstallationDirectory()
         {
@@ -282,7 +284,7 @@ public string GetInstallationDirectory()
 
         public override string ToString()
         {
-            return $"installationDirectory: {installationDirectory} | libary: {libary} | isInstalled: {isInstalled}";
+            return $"installationDirectory: {installationDirectory} | library: {library} | isInstalled: {isInstalled}";
         }
     }
 }
diff --git a/TinyNvidiaUpdateChecker/MainConsole.cs b/TinyNvidiaUpdateChecker/MainConsole.cs
@@ -72,10 +72,10 @@ class MainConsole
         /// </summary>
         public static bool noPrompt = false;
 
-	    /// <summary>
+        /// <summary>
         /// Dry run
         /// </summary>
-	    public static bool dryRun = false;    
+        public static bool dryRun = false;    
 
         /// <summary>
         /// Enable extended information
@@ -286,12 +286,12 @@ private static void CheckArgs(string[] args)
                 if (arg.ToLower() == "--quiet") {
                     showUI = false;
                 }
-				
-		        else if (arg.ToLower() == "--noprompt") {
+
+                else if (arg.ToLower() == "--noprompt") {
                     noPrompt = true;
                 }
 
-		        else if (arg.ToLower() == "--dry-run") {
+                else if (arg.ToLower() == "--dry-run") {
                     dryRun = true;
                 }
 
@@ -644,7 +644,7 @@ private static JObject GetDriverDownloadInfo(int gpuId, int osId, bool isDchDriv
                 WriteLine();
                 WriteLine(ex.ToString());
             }
-	
+
             callExit(1);
             return null;
         }
@@ -680,8 +680,8 @@ private static void CheckDependencies()
             }
 
             if (ConfigurationHandler.ReadSettingBool("Minimal install")) {
-                if (LibaryHandler.EvaluateLibary() == null) {
-                    WriteLine("Doesn't seem like neither WinRAR or 7-Zip is installed! We are disabling the minimal install feature for you.");
+                if (LibraryHandler.EvaluateLibrary() == null) {
+                    WriteLine("No compatible extract library was detected on the system. The minimal install feature has been disabled.");
                     ConfigurationHandler.SetSetting("Minimal install", "false");
                 }
             }
@@ -900,21 +900,21 @@ private static void MakeInstaller(bool silent, string savePath, string fileName)
             WriteLine();
             Write("Extracting drivers . . . ");
 
-            LibaryFile libaryFile = LibaryHandler.EvaluateLibary();
+            LibraryFile libraryFile = LibraryHandler.EvaluateLibrary();
             using var process = new Process();
-            LibaryHandler.Libary libary = libaryFile.LibaryName();
+            LibraryHandler.Library library = libraryFile.LibraryName();
 
             // Extract full driver to then analyze
-            if (libary == LibaryHandler.Libary.WINRAR) {
+            if (library == LibraryHandler.Library.WINRAR) {
                 process.StartInfo = new ProcessStartInfo {
-                    FileName = libaryFile.GetInstallationDirectory() + "winrar.exe",
+                    FileName = libraryFile.GetInstallationDirectory() + "winrar.exe",
                     WorkingDirectory = savePath,
                     Arguments = $"x {fileName} -optemp -y",
                     UseShellExecute = false
                 };
 
                 if (silent) process.StartInfo.Arguments += " -ibck";
-            } else if (libary == LibaryHandler.Libary.SEVENZIP) {
+            } else if (library == LibraryHandler.Library.SEVENZIP) {
                 process.StartInfo = new ProcessStartInfo {
                     WorkingDirectory = savePath,
                     Arguments = $"x {fileName} -otemp -y",
@@ -923,11 +923,11 @@ private static void MakeInstaller(bool silent, string savePath, string fileName)
                 };
 
                 if (silent) {
-                    process.StartInfo.FileName = libaryFile.GetInstallationDirectory() + "7z.exe";
+                    process.StartInfo.FileName = libraryFile.GetInstallationDirectory() + "7z.exe";
                 } else {
-                    process.StartInfo.FileName = libaryFile.GetInstallationDirectory() + "7zG.exe";
+                    process.StartInfo.FileName = libraryFile.GetInstallationDirectory() + "7zG.exe";
                 }
-            } else if (libary == LibaryHandler.Libary.NANAZIP) {
+            } else if (library == LibraryHandler.Library.NANAZIP) {
                 process.StartInfo = new ProcessStartInfo {
                     WorkingDirectory = savePath,
                     Arguments = $"x {fileName} -otemp -y",
@@ -1033,12 +1033,12 @@ private static void callExit(int exitNum)
                 WriteLine();
                 WriteLine("Press any key to exit...");
             }
-		
+
             if (showUI & !noPrompt) Console.ReadKey(true);
             FreeConsole();
             Environment.Exit(exitNum);
-        }	    
-	    
+        }
+        
         private static bool DoesDriverFileSizeMatch(string absoluteFilePath) {
             return new FileInfo(absoluteFilePath).Length == downloadFileSize;
         }

Original file line number	Diff line number	Diff line change
`@@ -5,78 +5,79 @@`
`5`	`5`	`using System.IO;`
`6`	`6`	`using System.Runtime.InteropServices;`
`7`	`7`	`using System.Text;`
`8`		`-using static TinyNvidiaUpdateChecker.Handlers.LibaryHandler;`
	`8`	`+using static TinyNvidiaUpdateChecker.Handlers.LibraryHandler;`
`9`	`9`
`10`	`10`	`namespace TinyNvidiaUpdateChecker.Handlers`
`11`	`11`	`{`
`12`	`12`
`13`		`- class LibaryHandler`
	`13`	`+ class LibraryHandler`
`14`	`14`	`{`
`15`	`15`	`private static bool is64 = Environment.Is64BitOperatingSystem;`
`16`	`16`
`17`		`- static List<LibaryRegistryPath> libaryRegistryList =`
	`17`	`+ static List<LibraryRegistryPath> libraryRegistryList`
	`18`	`+ =`
`18`	`19`	`[`
`19`	`20`	`/* WinRAR */`
`20`	`21`
`21`		`- new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Libary.WINRAR),`
`22`		`- new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Libary.WINRAR),`
	`22`	`+ new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Library.WINRAR),`
	`23`	`+ new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\WinRAR archiver", "InstallLocation", Library.WINRAR),`
`23`	`24`
`24`	`25`	`/* 7-Zip */`
`25`	`26`
`26`	`27`	`// amd64 installer on amd64 system, or x86 on x86 system`
`27`		`- new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Libary.SEVENZIP),`
	`28`	`+ new(Registry.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Library.SEVENZIP),`
`28`	`29`
`29`	`30`	`// x86 intaller on amd64 system`
`30`		`- new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Libary.SEVENZIP),`
	`31`	`+ new(Registry.LocalMachine, @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\7-Zip", "InstallLocation", Library.SEVENZIP),`
`31`	`32`
`32`	`33`	`// MSI amd64 installer on amd64 system, or x86 on x86 system`
`33`		`- new(Registry.LocalMachine, @"SOFTWARE\7-Zip", "Path", Libary.SEVENZIP),`
	`34`	`+ new(Registry.LocalMachine, @"SOFTWARE\7-Zip", "Path", Library.SEVENZIP),`
`34`	`35`
`35`	`36`	`// MSI x86 intaller on amd64 system`
`36`		`- new (Registry.LocalMachine, @"SOFTWARE\WOW6432Node\7-Zip", "Path", Libary.SEVENZIP),`
	`37`	`+ new (Registry.LocalMachine, @"SOFTWARE\WOW6432Node\7-Zip", "Path", Library.SEVENZIP),`
`37`	`38`	`];`
`38`	`39`
`39`		`- static List<LibaryPath> libaryPathList =`
	`40`	`+ static List<LibraryPath> LibraryPathList =`
`40`	`41`	`[`
`41`	`42`	`/* 7-Zip */`
`42`	`43`
`43`	`44`	`// scoop in user profile`
`44`		`- new([Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "scoop", "apps", "7zip", "current"], Libary.SEVENZIP),`
	`45`	`+ new([Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "scoop", "apps", "7zip", "current"], Library.SEVENZIP),`
`45`	`46`
`46`	`47`	`// scoop in Program Data`
`47`		`- new([Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "scoop", "apps", "7zip", "current"], Libary.SEVENZIP),`
	`48`	`+ new([Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "scoop", "apps", "7zip", "current"], Library.SEVENZIP),`
`48`	`49`
`49`	`50`	`// scoop local environment variable`
`50`		`- new([Environment.GetEnvironmentVariable("SCOOP", EnvironmentVariableTarget.User), "apps", "7zip", "current"], Libary.SEVENZIP),`
	`51`	`+ new([Environment.GetEnvironmentVariable("SCOOP", EnvironmentVariableTarget.User), "apps", "7zip", "current"], Library.SEVENZIP),`
`51`	`52`
`52`	`53`	`// scoop global environment variable`
`53`		`- new([Environment.GetEnvironmentVariable("SCOOP_GLOBAL", EnvironmentVariableTarget.Machine), "apps", "7zip", "current"], Libary.SEVENZIP),`
	`54`	`+ new([Environment.GetEnvironmentVariable("SCOOP_GLOBAL", EnvironmentVariableTarget.Machine), "apps", "7zip", "current"], Library.SEVENZIP),`
`54`	`55`
`55`	`56`	`// amd64 on amd64 system, or x86 on x86 system`
`56`		`- new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "7-Zip"], Libary.SEVENZIP),`
	`57`	`+ new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "7-Zip"], Library.SEVENZIP),`
`57`	`58`
`58`	`59`	`// x86 on amd64 system`
`59`		`- new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "7-Zip"], Libary.SEVENZIP),`
	`60`	`+ new([Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "7-Zip"], Library.SEVENZIP),`
`60`	`61`
`61`	`62`	`// custom path defined in config file`
`62`		`- new([ConfigurationHandler.ReadSetting("Custom 7-ZIP Libary Path", null, false)], Libary.SEVENZIP),`
	`63`	`+ new([ConfigurationHandler.ReadSetting("Custom 7-ZIP Library Path", null, false)], Library.SEVENZIP),`
`63`	`64`
`64`	`65`	`/* WinRAR */`
`65`		`- new([ConfigurationHandler.ReadSetting("Custom WinRAR Libary Path", null, false)], Libary.WINRAR)`
	`66`	`+ new([ConfigurationHandler.ReadSetting("Custom WinRAR Library Path", null, false)], Library.WINRAR)`
`66`	`67`	`];`
`67`	`68`
`68`		`- static Dictionary<string, Libary> cliList = new() {`
`69`		`- {"NanaZipC", Libary.NANAZIP} // NanaZip`
	`69`	`+ static Dictionary<string, Library> cliList = new() {`
	`70`	`+ {"NanaZipC", Library.NANAZIP} // NanaZip`
`70`	`71`	`};`
`71`	`72`
`72`		`- public enum Libary`
	`73`	`+ public enum Library`
`73`	`74`	`{`
`74`	`75`	`SEVENZIP,`
`75`	`76`	`WINRAR,`
`76`	`77`	`NANAZIP`
`77`	`78`	`}`
`78`	`79`
`79`		`- public static LibaryFile EvaluateLibary()`
	`80`	`+ public static LibraryFile EvaluateLibrary()`
`80`	`81`	`{`
`81`	`82`	`foreach (var entry in cliList)`
`82`	`83`	`{`
`@@ -98,13 +99,14 @@ public static LibaryFile EvaluateLibary()`
`98`	`99`	`if (process.ExitCode == 0)`
`99`	`100`	`{`
`100`	`101`	`string directoryPath = Path.GetDirectoryName(exePath) + @"\";`
`101`		`- return new LibaryFile(directoryPath, entry.Value, true);`
	`102`	`+ return new LibraryFile(directoryPath, entry.Value, true);`
`102`	`103`	`}`
`103`	`104`	`}`
`104`	`105`	`catch { }`
`105`	`106`	`}`
`106`	`107`
`107`		`- foreach (var entry in libaryRegistryList)`
	`108`	`+ foreach (var entry in libraryRegistryList)`
	`109`	`+`
`108`	`110`	`{`
`109`	`111`	`try`
`110`	`112`	`{`
`@@ -128,23 +130,23 @@ public static LibaryFile EvaluateLibary()`
`128`	`130`	`path += @"\";`
`129`	`131`	`}`
`130`	`132`
`131`		`- string exe = LibaryPath.GetExeFromLibary(entry.libary);`
	`133`	`+ string exe = LibraryPath.GetExeFromLibrary(entry.library);`
`132`	`134`	`string exePath = Path.Combine(path, exe);`
`133`	`135`
`134`	`136`	`if (Path.Exists(exePath))`
`135`	`137`	`{`
`136`		`- return new LibaryFile(path, entry.libary, true);`
	`138`	`+ return new LibraryFile(path, entry.library, true);`
`137`	`139`	`}`
`138`	`140`	`}`
`139`	`141`	`catch { }`
`140`	`142`	`}`
`141`	`143`
`142`		`- foreach (var entry in libaryPathList)`
	`144`	`+ foreach (var entry in LibraryPathList)`
`143`	`145`	`{`
`144`	`146`	`if (entry.validate())`
`145`	`147`	`{`
`146`	`148`	`string path = Path.Combine(entry.path) + @"\";`
`147`		`- return new LibaryFile(path, entry.libary, true);`
	`149`	`+ return new LibraryFile(path, entry.library, true);`
`148`	`150`	`}`
`149`	`151`	`}`
`150`	`152`
`@@ -167,22 +169,22 @@ public static string GetMainModuleFileName(this Process process, int buffer = 10`
`167`	`169`	`}`
`168`	`170`	`}`
`169`	`171`
`170`		`- class LibaryPath`
	`172`	`+ class LibraryPath`
`171`	`173`	`{`
`172`	`174`	`public string[] path;`
`173`		`- public LibaryHandler.Libary libary;`
	`175`	`+ public LibraryHandler.Library library;`
`174`	`176`
`175`		`- public LibaryPath(string[] path, LibaryHandler.Libary libary)`
	`177`	`+ public LibraryPath(string[] path, LibraryHandler.Library library)`
`176`	`178`	`{`
`177`	`179`	`this.path = path;`
`178`		`- this.libary = libary;`
	`180`	`+ this.library = library;`
`179`	`181`	`}`
`180`	`182`
`181`	`183`	`public bool validate()`
`182`	`184`	`{`
`183`	`185`	`try`
`184`	`186`	`{`
`185`		`- string exe = GetExeFromLibary(this.libary);`
	`187`	`+ string exe = GetExeFromLibrary(this.library);`
`186`	`188`	`string path = Path.Combine([.. this.path, exe]);`
`187`	`189`
`188`	`190`	`if (Path.Exists(path))`
`@@ -195,30 +197,30 @@ public bool validate()`
`195`	`197`	`return false;`
`196`	`198`	`}`
`197`	`199`
`198`		`- public static string GetExeFromLibary(Libary libary)`
	`200`	`+ public static string GetExeFromLibrary(Library library)`
`199`	`201`	`{`
`200`		`- return libary switch`
	`202`	`+ return library switch`
`201`	`203`	`{`
`202`		`- Libary.SEVENZIP => "7z.exe",`
`203`		`- Libary.WINRAR => "winrar.exe",`
	`204`	`+ Library.SEVENZIP => "7z.exe",`
	`205`	`+ Library.WINRAR => "winrar.exe",`
`204`	`206`	`_ => "",`
`205`	`207`	`};`
`206`	`208`	`}`
`207`	`209`	`}`
`208`	`210`
`209`		`- class LibaryRegistryPath`
	`211`	`+ class LibraryRegistryPath`
`210`	`212`	`{`
`211`	`213`	`public RegistryKey key;`
`212`	`214`	`public string path;`
`213`	`215`	`public string name;`
`214`		`- public LibaryHandler.Libary libary;`
	`216`	`+ public LibraryHandler.Library library;`
`215`	`217`
`216`		`- public LibaryRegistryPath(RegistryKey key, string path, string name, LibaryHandler.Libary libary)`
	`218`	`+ public LibraryRegistryPath(RegistryKey key, string path, string name, LibraryHandler.Library library)`
`217`	`219`	`{`
`218`	`220`	`this.key = key;`
`219`	`221`	`this.path = path;`
`220`	`222`	`this.name = name;`
`221`		`- this.libary = libary;`
	`223`	`+ this.library = library;`
`222`	`224`	`}`
`223`	`225`
`224`	`226`	`public RegistryHive getRegistryHive()`
`@@ -237,43 +239,43 @@ public RegistryHive getRegistryHive()`
`237`	`239`	`/// <summary>`
`238`	`240`	`/// Libaries that can extract the nvidia driver file`
`239`	`241`	`/// </summary>`
`240`		`- class LibaryFile`
	`242`	`+ class LibraryFile`
`241`	`243`	`{`
`242`	`244`	`string installationDirectory;`
`243`		`- LibaryHandler.Libary libary;`
	`245`	`+ LibraryHandler.Library library;`
`244`	`246`	`bool isInstalled;`
`245`	`247`
`246`		`- public LibaryFile(string installationDirectory, LibaryHandler.Libary libary, bool isInstalled)`
	`248`	`+ public LibraryFile(string installationDirectory, LibraryHandler.Library library, bool isInstalled)`
`247`	`249`	`{`
`248`	`250`	`this.installationDirectory = installationDirectory;`
`249`		`- this.libary = libary;`
	`251`	`+ this.library = library;`
`250`	`252`	`this.isInstalled = isInstalled;`
`251`	`253`	`}`
`252`	`254`
`253`		`- public LibaryFile(LibaryHandler.Libary libary, bool isInstalled)`
	`255`	`+ public LibraryFile(LibraryHandler.Library library, bool isInstalled)`
`254`	`256`	`{`
`255`		`- this.libary = libary;`
	`257`	`+ this.library = library;`
`256`	`258`	`this.isInstalled = isInstalled;`
`257`	`259`	`}`
`258`	`260`
`259`	`261`	`/// <summary>`
`260`		`- /// Is the libary installed?`
	`262`	`+ /// Is the library installed?`
`261`	`263`	`/// </summary>`
`262`	`264`	`public bool IsInstalled()`
`263`	`265`	`{`
`264`	`266`	`return isInstalled;`
`265`	`267`	`}`
`266`	`268`
`267`	`269`	`/// <summary>`
`268`		`- /// Libary name`
	`270`	`+ /// Library name`
`269`	`271`	`/// </summary>`
`270`		`- public LibaryHandler.Libary LibaryName()`
	`272`	`+ public LibraryHandler.Library LibraryName()`
`271`	`273`	`{`
`272`		`- return libary;`
	`274`	`+ return library;`
`273`	`275`	`}`
`274`	`276`
`275`	`277`	`/// <summary>`
`276`		`- /// Get the absolute path to the libary, ending with a backslash`
	`278`	`+ /// Get the absolute path to the library, ending with a backslash`
`277`	`279`	`/// </summary>`
`278`	`280`	`public string GetInstallationDirectory()`
`279`	`281`	`{`
`@@ -282,7 +284,7 @@ public string GetInstallationDirectory()`
`282`	`284`
`283`	`285`	`public override string ToString()`
`284`	`286`	`{`
`285`		`- return $"installationDirectory: {installationDirectory} \| libary: {libary} \| isInstalled: {isInstalled}";`
	`287`	`+ return $"installationDirectory: {installationDirectory} \| library: {library} \| isInstalled: {isInstalled}";`
`286`	`288`	`}`
`287`	`289`	`}`
`288`	`290`	`}`