xulbux 1.6.7__py3-none-any.whl → 1.6.9__py3-none-any.whl

xulbux/__init__.py

@@ -1,45 +1,13 @@
-"""
- >>> import xulbux as xx
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  • CUSTOM TYPES:
-     • rgba(int,int,int,float)
-     • hsla(int,int,int,float)
-     • hexa(str)
-  • PATH OPERATIONS          xx.Path
-  • FILE OPERATIONS          xx.File
-  • JSON FILE OPERATIONS     xx.Json
-  • SYSTEM ACTIONS           xx.System
-  • MANAGE THE ENV PATH VAR  xx.EnvPath
-  • CONSOLE LOG AND ACTIONS  xx.Console
-  • EASY PRETTY PRINTING     xx.FormatCodes
-  • WORKING WITH COLORS      xx.Color
-  • DATA OPERATIONS          xx.Data
-  • STRING OPERATIONS        xx.String
-  • CODE STRING OPERATIONS   xx.Code
-  • REGEX PATTERN TEMPLATES  xx.Regex
-"""
-
-__version__ = "1.6.7"
+__version__ = "1.6.9"
 __author__ = "XulbuX"
 __email__ = "xulbux.real@gmail.com"
 __license__ = "MIT"
-__copyright__ = "Copyright (c) 2024 XulbuX"
+__copyright__ = "Copyright (c) 2025 XulbuX"
 __url__ = "https://github.com/XulbuX/PythonLibraryXulbuX"
 __description__ = "A library which includes a lot of really helpful functions."
 __all__ = [
-    "_consts_",
-    "xx_console",
-    "xx_code",
-    "xx_color",
-    "xx_data",
-    "xx_env_path",
-    "xx_file",
-    "xx_format_codes",
-    "xx_json",
-    "xx_path",
-    "xx_regex",
-    "xx_string",
-    "xx_system",
+    "_consts_", "xx_code", "xx_color", "xx_console", "xx_data", "xx_env_path", "xx_file", "xx_format_codes", "xx_json",
+    "xx_path", "xx_regex", "xx_string", "xx_system"
 ]
 
 from ._consts_ import *

xulbux/_cli_.py

@@ -1,5 +1,5 @@
-from . import __version__
 from ._consts_ import COLOR
+from . import __version__
 from .xx_format_codes import FormatCodes
 from .xx_console import Console
 
@@ -33,17 +33,17 @@ def help_command():
        [dim](•) [{color['class']}]rgba[{color['punctuators']}]/([i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]float[_|{color['punctuators']}])[*]
        [dim](•) [{color['class']}]hsla[{color['punctuators']}]/([i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]float[_|{color['punctuators']}])[*]
        [dim](•) [{color['class']}]hexa[{color['punctuators']}]/([i|{color['types']}]str[_|{color['punctuators']}]|[i|{color['types']}]int[_|{color['punctuators']}])[*]
+    [dim](•) CODE STRING OPERATIONS   [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Code[*]
+    [dim](•) WORKING WITH COLORS      [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Color[*]
+    [dim](•) CONSOLE LOG AND ACTIONS  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Console[*]
     [dim](•) PATH OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Path[*]
     [dim](•) FILE OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]File[*]
     [dim](•) JSON FILE OPERATIONS     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Json[*]
     [dim](•) SYSTEM ACTIONS           [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]System[*]
     [dim](•) MANAGE THE ENV PATH VAR  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]EnvPath[*]
-    [dim](•) CONSOLE LOG AND ACTIONS  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Console[*]
     [dim](•) EASY PRETTY PRINTING     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]FormatCodes[*]
-    [dim](•) WORKING WITH COLORS      [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Color[*]
     [dim](•) DATA OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Data[*]
     [dim](•) STRING OPERATIONS        [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]String[*]
-    [dim](•) CODE STRING OPERATIONS   [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Code[*]
     [dim](•) REGEX PATTERN TEMPLATES  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Regex[*]
   [_]
   [dim](Press any key to exit...)

xulbux/xx_code.py

@@ -55,46 +55,61 @@ class Code:
     @staticmethod
     def is_js(code: str, funcs: list = ["__", "$t", "$lang"]) -> bool:
         """Will check if the code is very likely to be JavaScript."""
-        funcs = "|".join(funcs)
-        js_pattern = _rx.compile(
-            Regex.outside_strings(
-                r"""^(?:
-                (\$[\w_]+)\s*                      # JQUERY-STYLE VARIABLES
-                |(\$[\w_]+\s*\()                   # JQUERY-STYLE FUNCTION CALLS
-                |((""" + funcs + r")" + Regex.brackets("()") + r"""\s*) # PREDEFINED FUNCTION CALLS
-                |(\bfunction\s*\()                 # FUNCTION DECLARATIONS
-                |(\b(var|let|const)\s+[\w_]+\s*=)  # VARIABLE DECLARATIONS
-                |(\b(if|for|while|switch)\s*\()    # CONTROL STRUCTURES
-                |(\b(return|throw)\s+)             # RETURN OR THROW STATEMENTS
-                |(\bnew\s+[\w_]+\()                # OBJECT INSTANTIATION
-                |(\b[\w_]+\s*=>\s*{)               # ARROW FUNCTIONS
-                |(\b(true|false|null|undefined)\b) # JAVASCRIPT LITERALS
-                |(\b(document|window|console)\.)   # BROWSER OBJECTS
-                |(\b[\w_]+\.(forEach|map|filter|reduce)\() # ARRAY METHODS
-                |(/[^/\n\r]*?/[gimsuy]*)           # REGULAR EXPRESSIONS
-                |(===|!==|\+\+|--|\|\||&&)         # JAVASCRIPT-SPECIFIC OPERATORS
-                |(\bclass\s+[\w_]+)                # CLASS DECLARATIONS
-                |(\bimport\s+.*?from\s+)           # IMPORT STATEMENTS
-                |(\bexport\s+(default\s+)?)        # EXPORT STATEMENTS
-                |(\basync\s+function)              # ASYNC FUNCTIONS
-                |(\bawait\s+)                      # AWAIT KEYWORD
-                |(\btry\s*{)                       # TRY-CATCH BLOCKS
-                |(\bcatch\s*\()
-                |(\bfinally\s*{)
-                |(\byield\s+)                      # GENERATOR FUNCTIONS
-                |(\[.*?\]\s*=)                     # DESTRUCTURING ASSIGNMENT
-                |(\.\.\.)                          # SPREAD OPERATOR
-                |(==|!=|>=|<=|>|<)                 # COMPARISON OPERATORS
-                |(\+=|-=|\*=|/=|%=|\*\*=)          # COMPOUND ASSIGNMENT OPERATORS
-                |(\+|-|\*|/|%|\*\*)                # ARITHMETIC OPERATORS
-                |(&|\||\^|~|<<|>>|>>>)             # BITWISE OPERATORS
-                |(\?|:)                            # TERNARY OPERATOR
-                |(\bin\b)                          # IN OPERATOR
-                |(\binstanceof\b)                  # INSTANCEOF OPERATOR
-                |(\bdelete\b)                      # DELETE OPERATOR
-                |(\btypeof\b)                      # TYPEOF OPERATOR
-                |(\bvoid\b)                        # VOID OPERATOR
-                )[\s\S]*$"""
-            ), _rx.VERBOSE | _rx.IGNORECASE
-        )
-        return bool(js_pattern.fullmatch(code))
+        if not code or len(code.strip()) < 3:
+            return False
+        for func in funcs:
+            if _rx.match(r"^[\s\n]*" + _rx.escape(func) + r"\([^\)]*\)[\s\n]*$", code):
+                return True
+        direct_js_patterns = [
+            r"^[\s\n]*\$\(['\"][^'\"]+['\"]\)\.[\w]+\([^\)]*\);?[\s\n]*$",  # jQuery calls
+            r"^[\s\n]*\$\.[a-zA-Z]\w*\([^\)]*\);?[\s\n]*$",  # $.ajax(), etc.
+            r"^[\s\n]*\(\s*function\s*\(\)\s*\{.*\}\s*\)\(\);?[\s\n]*$",  # IIFE
+            r"^[\s\n]*document\.[a-zA-Z]\w*\([^\)]*\);?[\s\n]*$",  # document.getElementById()
+            r"^[\s\n]*window\.[a-zA-Z]\w*\([^\)]*\);?[\s\n]*$",  # window.alert()
+            r"^[\s\n]*console\.[a-zA-Z]\w*\([^\)]*\);?[\s\n]*$",  # console.log()
+        ]
+        for pattern in direct_js_patterns:
+            if _rx.match(pattern, code):
+                return True
+        arrow_function_patterns = [
+            r"^[\s\n]*\b[\w_]+\s*=\s*\([^\)]*\)\s*=>\s*[^;{]*[;]?[\s\n]*$",  # const x = (y) => y*2;
+            r"^[\s\n]*\b[\w_]+\s*=\s*[\w_]+\s*=>\s*[^;{]*[;]?[\s\n]*$",  # const x = y => y*2;
+            r"^[\s\n]*\(\s*[\w_,\s]+\s*\)\s*=>\s*[^;{]*[;]?[\s\n]*$",  # (x) => x*2
+            r"^[\s\n]*[\w_]+\s*=>\s*[^;{]*[;]?[\s\n]*$",  # x => x*2
+        ]
+        for pattern in arrow_function_patterns:
+            if _rx.match(pattern, code):
+                return True
+        funcs_pattern = r"(" + "|".join(_rx.escape(f) for f in funcs) + r")" + Regex.brackets("()")
+        js_indicators = [(r"\b(var|let|const)\s+[\w_$]+", 2),  # JS variable declarations
+                         (r"\$[\w_$]+\s*=", 2),  # jQuery-style variables
+                         (r"\$[\w_$]+\s*\(", 2),  # jQuery function calls
+                         (r"\bfunction\s*[\w_$]*\s*\(", 2),  # Function declarations
+                         (r"[\w_$]+\s*=\s*function\s*\(", 2),  # Function assignments
+                         (r"\b[\w_$]+\s*=>\s*[\{\(]", 2),  # Arrow functions
+                         (r"\(function\s*\(\)\s*\{", 2),  # IIFE pattern
+                         (funcs_pattern, 2),  # Custom predefined functions
+                         (r"\b(true|false|null|undefined)\b", 1),  # JS literals
+                         (r"===|!==|\+\+|--|\|\||&&", 1.5),  # JS-specific operators
+                         (r"\bnew\s+[\w_$]+\s*\(", 1.5),  # Object instantiation with new
+                         (r"\b(document|window|console|Math|Array|Object|String|Number)\.", 2),  # JS objects
+                         (r"\basync\s+function|\bawait\b", 2),  # Async/await
+                         (r"\b(if|for|while|switch)\s*\([^)]*\)\s*\{", 1),  # Control structures with braces
+                         (r"\btry\s*\{[^}]*\}\s*catch\s*\(", 1.5),  # Try-catch
+                         (r";[\s\n]*$", 0.5),  # Semicolon line endings
+                         ]
+        js_score = 0
+        line_endings = [line.strip() for line in code.splitlines() if line.strip()]
+        semicolon_endings = sum(1 for line in line_endings if line.endswith(';'))
+        if semicolon_endings >= 1:
+            js_score += min(semicolon_endings, 2)
+        opening_braces = code.count('{')
+        closing_braces = code.count('}')
+        if opening_braces > 0 and opening_braces == closing_braces:
+            js_score += 1
+        for pattern, score in js_indicators:
+            regex = _rx.compile(pattern, _rx.IGNORECASE)
+            matches = regex.findall(code)
+            if matches:
+                js_score += len(matches) * score
+        return js_score >= 2

xulbux/xx_color.py

@@ -97,12 +97,7 @@ class rgba:
     def __eq__(self, other: "rgba") -> bool:
         if not isinstance(other, rgba):
             return False
-        return (self.r, self.g, self.b, self.a) == (
-            other[0],
-            other[1],
-            other[2],
-            other[3],
-        )
+        return (self.r, self.g, self.b, self.a) == (other.r, other.g, other.b, other.a)
 
     def dict(self) -> dict:
         """Returns the color components as a dictionary with keys `'r'`, `'g'`, `'b'` and optionally `'a'`"""
@@ -156,9 +151,15 @@ class rgba:
             self.a = 1 - self.a
         return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
-    def grayscale(self) -> "rgba":
-        """Converts the color to grayscale using the luminance formula"""
-        self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b)
+    def grayscale(self, method: str = "wcag2") -> "rgba":
+        """Converts the color to grayscale using the luminance formula.\n
+        ------------------------------------------------------------------
+        The `method` is the luminance calculation method to use:
+        - `"wcag2"` WCAG 2.0 standard (default and most accurate for perception)
+        - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
+        - `"simple"` Simple arithmetic mean (less accurate)
+        - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
+        self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b, method=method)
         return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     def blend(self, other: "rgba", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
@@ -286,20 +287,15 @@ class hsla:
         return ((self.h, self.s, self.l) + (() if self.a is None else (self.a, )))[index]
 
     def __repr__(self) -> str:
-        return f'hsla({self.h}, {self.s}, {self.l}{"" if self.a is None else f", {self.a}"})'
+        return f'hsla({self.h}°, {self.s}%, {self.l}%{"" if self.a is None else f", {self.a}"})'
 
     def __str__(self) -> str:
-        return f'({self.h}, {self.s}, {self.l}{"" if self.a is None else f", {self.a}"})'
+        return f'({self.h}°, {self.s}%, {self.l}%{"" if self.a is None else f", {self.a}"})'
 
     def __eq__(self, other: "hsla") -> bool:
         if not isinstance(other, hsla):
             return False
-        return (self.h, self.s, self.l, self.a) == (
-            other[0],
-            other[1],
-            other[2],
-            other[3],
-        )
+        return (self.h, self.s, self.l, self.a) == (other.h, other.s, other.l, other.a)
 
     def dict(self) -> dict:
         """Returns the color components as a dictionary with keys `'h'`, `'s'`, `'l'` and optionally `'a'`"""
@@ -363,9 +359,15 @@ class hsla:
             self.a = 1 - self.a
         return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
-    def grayscale(self) -> "hsla":
-        """Converts the color to grayscale using the luminance formula"""
-        l = Color.luminance(*self._hsl_to_rgb(self.h, self.s, self.l))
+    def grayscale(self, method: str = "wcag2") -> "hsla":
+        """Converts the color to grayscale using the luminance formula.\n
+        ------------------------------------------------------------------
+        The `method` is the luminance calculation method to use:
+        - `"wcag2"` WCAG 2.0 standard (default and most accurate for perception)
+        - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
+        - `"simple"` Simple arithmetic mean (less accurate)
+        - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
+        l = Color.luminance(*self._hsl_to_rgb(self.h, self.s, self.l), method=method)
         self.h, self.s, self.l, _ = rgba(l, l, l, _validate=False).to_hsla().values()
         return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
@@ -520,14 +522,10 @@ class hexa:
         return f'#{self.r:02X}{self.g:02X}{self.b:02X}{"" if self.a is None else f"{int(self.a * 255):02X}"}'
 
     def __eq__(self, other: "hexa") -> bool:
+        """Returns whether the other color is equal to this one."""
         if not isinstance(other, hexa):
             return False
-        return (self.r, self.g, self.b, self.a) == (
-            other[0],
-            other[1],
-            other[2],
-            other[3],
-        )
+        return (self.r, self.g, self.b, self.a) == (other.r, other.g, other.b, other.a)
 
     def dict(self) -> dict:
         """Returns the color components as a dictionary with hex string values for keys `'r'`, `'g'`, `'b'` and optionally `'a'`"""
@@ -540,9 +538,9 @@ class hexa:
             )
         )
 
-    def values(self) -> tuple:
+    def values(self, round_alpha: bool = True) -> tuple:
         """Returns the color components as separate values `r, g, b, a`"""
-        return self.r, self.g, self.b, self.a
+        return self.r, self.g, self.b, None if self.a is None else (round(self.a, 2) if round_alpha else self.a)
 
     def to_rgba(self, round_alpha: bool = True) -> "rgba":
         """Returns the color as a `rgba()` color"""
@@ -594,9 +592,15 @@ class hexa:
             self.a = 1 - self.a
         return hexa("", self.r, self.g, self.b, self.a)
 
-    def grayscale(self) -> "hexa":
-        """Converts the color to grayscale using the luminance formula"""
-        self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b)
+    def grayscale(self, method: str = "wcag2") -> "hexa":
+        """Converts the color to grayscale using the luminance formula.\n
+        ------------------------------------------------------------------
+        The `method` is the luminance calculation method to use:
+        - `"wcag2"` WCAG 2.0 standard (default and most accurate for perception)
+        - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
+        - `"simple"` Simple arithmetic mean (less accurate)
+        - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
+        self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b, method=method)
         return hexa("", self.r, self.g, self.b, self.a)
 
     def blend(self, other: "hexa", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
@@ -647,14 +651,20 @@ class Color:
                         0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
                         and (0 <= color[3] <= 1 or color[3] is None)
                     )
-                return 0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
+                elif len(color) == 3:
+                    return 0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
+                else:
+                    return False
             elif isinstance(color, dict):
                 if allow_alpha and Color.has_alpha(color):
                     return (
                         0 <= color["r"] <= 255 and 0 <= color["g"] <= 255 and 0 <= color["b"] <= 255
                         and (0 <= color["a"] <= 1 or color["a"] is None)
                     )
-                return 0 <= color["r"] <= 255 and 0 <= color["g"] <= 255 and 0 <= color["b"] <= 255
+                elif len(color) == 3:
+                    return 0 <= color["r"] <= 255 and 0 <= color["g"] <= 255 and 0 <= color["b"] <= 255
+                else:
+                    return False
             elif isinstance(color, str):
                 return bool(_re.fullmatch(Regex.rgba_str(allow_alpha=allow_alpha), color))
             return False
@@ -672,16 +682,20 @@ class Color:
                         0 <= color[0] <= 360 and 0 <= color[1] <= 100 and 0 <= color[2] <= 100
                         and (0 <= color[3] <= 1 or color[3] is None)
                     )
-                else:
+                elif len(color) == 3:
                     return 0 <= color[0] <= 360 and 0 <= color[1] <= 100 and 0 <= color[2] <= 100
+                else:
+                    return False
             elif isinstance(color, dict):
                 if allow_alpha and Color.has_alpha(color):
                     return (
                         0 <= color["h"] <= 360 and 0 <= color["s"] <= 100 and 0 <= color["l"] <= 100
                         and (0 <= color["a"] <= 1 or color["a"] is None)
                     )
-                else:
+                elif len(color) == 3:
                     return 0 <= color["h"] <= 360 and 0 <= color["s"] <= 100 and 0 <= color["l"] <= 100
+                else:
+                    return False
             elif isinstance(color, str):
                 return bool(_re.fullmatch(Regex.hsla_str(allow_alpha=allow_alpha), color))
         except Exception:
@@ -691,9 +705,9 @@ class Color:
     def is_valid_hexa(color: str | int, allow_alpha: bool = True, get_prefix: bool = False) -> bool | tuple[bool, str]:
         try:
             if isinstance(color, hexa):
-                return (True, "#")
+                return (True, "#") if get_prefix else True
             elif isinstance(color, int):
-                is_valid = 0 <= color <= (0xFFFFFFFF if allow_alpha else 0xFFFFFF)
+                is_valid = 0x000000 <= color <= (0xFFFFFFFF if allow_alpha else 0xFFFFFF)
                 return (is_valid, "0x") if get_prefix else is_valid
             elif isinstance(color, str):
                 color, prefix = ((color[1:], "#") if color.startswith("#") else
@@ -705,7 +719,7 @@ class Color:
 
     @staticmethod
     def is_valid(color: str | list | tuple | dict, allow_alpha: bool = True) -> bool:
-        return (
+        return bool(
             Color.is_valid_rgba(color, allow_alpha) or Color.is_valid_hsla(color, allow_alpha)
             or Color.is_valid_hexa(color, allow_alpha)
         )
@@ -777,7 +791,7 @@ class Color:
         --------------------------------------------------------------------------------------------------
         If `only_first` is `True` only the first found color will be returned (not as a list)."""
         if only_first:
-            match = _re.search(Regex.rgb_str(allow_alpha=True), string)
+            match = _re.search(Regex.rgba_str(allow_alpha=True), string)
             if not match:
                 return None
             m = match.groups()
@@ -789,7 +803,7 @@ class Color:
                 _validate=False,
             )
         else:
-            matches = _re.findall(Regex.rgb_str(allow_alpha=True), string)
+            matches = _re.findall(Regex.rgba_str(allow_alpha=True), string)
             if not matches:
                 return None
             return [
@@ -865,28 +879,47 @@ class Color:
             raise ValueError(f"Invalid HEX integer '0x{hex_str}': expected in range [0x000000, 0xFFFFFF]")
 
     @staticmethod
-    def luminance(r: int, g: int, b: int, output_type: type = None) -> int | float:
-        """Gets the colors luminance using the luminance formula.\n
-        ------------------------------------------------------------
-        The param `output_type` can be set to:
-        - `int`   =⠀integer in [0, 100]
-        - `float` =⠀float in [0.0, 1.0]
-        - `None`  =⠀integer in [0, 255]"""
+    def luminance(r: int, g: int, b: int, output_type: type = None, method: str = "wcag2") -> int | float:
+        """Calculates the relative luminance of a color according to various standards.\n
+        ----------------------------------------------------------------------------------
+        The `output_type` controls the range of the returned luminance value:
+        - `int` returns integer in [0, 100]
+        - `float` returns float in [0.0, 1.0]
+        - `None` returns integer in [0, 255]\n
+        The `method` is the luminance calculation method to use:
+        - `"wcag2"` WCAG 2.0 standard (default and most accurate for perception)
+        - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
+        - `"simple"` Simple arithmetic mean (less accurate)
+        - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
         r, g, b = r / 255.0, g / 255.0, b / 255.0
-        if r < 0.03928:
-            r = r / 12.92
+        if method == "simple":
+            luminance = (r + g + b) / 3
+        elif method == "bt601":
+            luminance = 0.299 * r + 0.587 * g + 0.114 * b
+        elif method == "wcag3":
+            r = Color._linearize_srgb(r)
+            g = Color._linearize_srgb(g)
+            b = Color._linearize_srgb(b)
+            luminance = 0.2126729 * r + 0.7151522 * g + 0.0721750 * b
         else:
-            r = ((r + 0.055) / 1.055)**2.4
-        if g < 0.03928:
-            g = g / 12.92
+            r = Color._linearize_srgb(r)
+            g = Color._linearize_srgb(g)
+            b = Color._linearize_srgb(b)
+            luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b
+        if output_type == int:
+            return round(luminance * 100)
+        elif output_type == float:
+            return luminance
         else:
-            g = ((g + 0.055) / 1.055)**2.4
-        if b < 0.03928:
-            b = b / 12.92
+            return round(luminance * 255)
+
+    @staticmethod
+    def _linearize_srgb(c: float) -> float:
+        """Helper method to linearize sRGB component following the WCAG standard."""
+        if c <= 0.03928:
+            return c / 12.92
         else:
-            b = ((b + 0.055) / 1.055)**2.4
-        l = 0.2126 * r + 0.7152 * g + 0.0722 * b
-        return round(l * 100) if isinstance(output_type, int) else round(l * 255) if output_type is None else l
+            return ((c + 0.055) / 1.055)**2.4
 
     @staticmethod
     def text_color_for_on_bg(text_bg_color: rgba | hexa) -> rgba | hexa: